- "ninja_helper.cc",

- "ninja_helper.h",

- "ninja_helper_unittest.cc",

- !ResolveForwardDependentConfigs(target, err))

- const Toolchain* toolchain,

- NinjaTargetWriter::RunAndWriteFile(target, toolchain);

- const Toolchain* toolchain =

- builder->GetToolchain(target->settings()->toolchain_label());

- DCHECK(toolchain);

-

- g_scheduler->ScheduleWork(

- base::Bind(&BackgroundDoWrite, target, toolchain, deps));

- // For writing commands to ninja files.

-SourceFileType GetSourceFileType(const SourceFile& file) {

- base::StringPiece extension = FindExtension(&file.value());

- if (extension == "cc" || extension == "cpp" || extension == "cxx")

- return SOURCE_CC;

- if (extension == "h")

- return SOURCE_H;

- if (extension == "c")

- return SOURCE_C;

- if (extension == "m")

- return SOURCE_M;

- if (extension == "mm")

- return SOURCE_MM;

- if (extension == "rc")

- return SOURCE_RC;

- if (extension == "S" || extension == "s")

- return SOURCE_S;

- if (extension == "o" || extension == "obj")

- return SOURCE_O;

-

- return SOURCE_UNKNOWN;

-}

-

- const Value& originating,

- *err = Err(originating, "File is not inside output directory.",

- const OutputFile& toolchain_subdir = settings->toolchain_output_subdir();

-

- std::string result = settings->build_settings()->build_dir().value();

- if (!toolchain_subdir.value().empty())

- result.append(toolchain_subdir.value());

-

- return SourceDir(SourceDir::SWAP_IN, &result);

- const OutputFile& toolchain_subdir = settings->toolchain_output_subdir();

-

- std::string result = settings->build_settings()->build_dir().value();

- if (!toolchain_subdir.value().empty())

- result.append(toolchain_subdir.value());

- result.append("gen/");

- return SourceDir(SourceDir::SWAP_IN, &result);

- SourceDir toolchain = GetToolchainOutputDir(settings);

- std::string ret;

- toolchain.SwapValue(&ret);

- ret.append("obj/");

- ret.append(&source_dir.value()[2], source_dir.value().size() - 2);

- // (Put system-absolute stuff in the root obj directory.)

-

- return SourceDir(SourceDir::SWAP_IN, &ret);

- SourceDir toolchain = GetToolchainGenDir(settings);

- std::string ret;

- toolchain.SwapValue(&ret);

- ret.append(&source_dir.value()[2], source_dir.value().size() - 2);

- // (Put system-absolute stuff in the root gen directory.)

-

- return SourceDir(SourceDir::SWAP_IN, &ret);

- return GetOutputDirForSourceDir(target->settings(), target->label().dir());

- return GetGenDirForSourceDir(target->settings(), target->label().dir());

- return GetOutputDirForSourceDir(scope->settings(), scope->GetSourceDir());

-enum SourceFileType {

- SOURCE_UNKNOWN,

- SOURCE_ASM,

- SOURCE_C,

- SOURCE_CC,

- SOURCE_H,

- SOURCE_M,

- SOURCE_MM,

- SOURCE_S,

- SOURCE_RC,

- SOURCE_O, // Object files can be inputs, too. Also counts .obj.

-};

-

-SourceFileType GetSourceFileType(const SourceFile& file);

-

-// The originating value will be blamed in the error.

- const Value& originating,

- const Label& toolchain_label, bool is_default);

- const SourceDir& source_dir);

- EXPECT_FALSE(EnsureStringIsInOutputDir(output_dir, "//foo", Value(), &err));

- EXPECT_FALSE(EnsureStringIsInOutputDir(output_dir, "//out/Debugit", Value(),

- EXPECT_TRUE(EnsureStringIsInOutputDir(output_dir, "//out/Debug/", Value(),

- EXPECT_TRUE(EnsureStringIsInOutputDir(output_dir, "//out/Debug/foo", Value(),

- Value(), &err));

- GetOutputDirForSourceDir(&default_settings,

- SourceDir("//")).value());

- GetOutputDirForSourceDir(&default_settings,

- SourceDir("//foo/bar/")).value());

- GetOutputDirForSourceDir(&other_settings, SourceDir("//")).value());

- GetGenDirForSourceDir(&default_settings, SourceDir("//")).value());

- GetGenDirForSourceDir(&default_settings,

- SourceDir("//foo/bar/")).value());

- GetGenDirForSourceDir(&other_settings, SourceDir("//")).value());

- GetGenDirForSourceDir(&other_settings,

- SourceDir("//foo/bar/")).value());

- EXPECT_EQ("//gen/",

- GetGenDirForSourceDir(&settings, SourceDir("//")).value());

-#include "tools/gn/ninja_helper.h"

-namespace {

-

-void GetOutputsForTarget(const Settings* settings,

- const Target* target,

- std::vector<SourceFile>* ret) {

- switch (target->output_type()) {

- case Target::ACTION: {

- // Actions just use the output list with no substitution.

- std::vector<SourceFile> sources;

- sources.push_back(SourceFile());

- SubstitutionWriter::GetListAsSourceFiles(

- settings, target->action_values().outputs(), ret);

- break;

- }

-

- case Target::COPY_FILES:

- case Target::ACTION_FOREACH:

- SubstitutionWriter::ApplyListToSources(

- settings, target->action_values().outputs(), target->sources(), ret);

- break;

-

- case Target::EXECUTABLE:

- case Target::SHARED_LIBRARY:

- case Target::STATIC_LIBRARY:

- // Return the resulting binary file. Currently, fall through to the

- // Ninja helper below which will compute the main output name.

- //

- // TODO(brettw) some targets have secondary files which should go into

- // the list after the main (like shared libraries on Windows have an

- // import library).

- case Target::GROUP:

- case Target::SOURCE_SET: {

- // These return the stamp file, which is computed by the NinjaHelper.

- NinjaHelper helper(settings->build_settings());

- OutputFile output_file = helper.GetTargetOutputFile(target);

-

- // The output file is relative to the build dir.

- ret->push_back(SourceFile(

- settings->build_settings()->build_dir().value() +

- output_file.value()));

- break;

- }

-

- default:

- NOTREACHED();

- }

-}

-

-} // namespace

-

- GetOutputsForTarget(scope->settings(), target, &files);

-TEST_F(GetTargetOutputsTest, Executable) {

- Target* exe = new Target(setup_.settings(), GetLabel("//foo/", "bar"));

- exe->set_output_type(Target::EXECUTABLE);

- items_.push_back(new scoped_ptr<Item>(exe));

-

- Err err;

- Value result = GetTargetOutputs("//foo:bar", &err);

- ASSERT_FALSE(err.has_error());

- // The TestWithScope declares that the build is Linux, so we'll have no

- // extension for the binaries.

- AssertSingleStringEquals(result, "//out/Debug/bar");

-}

-

-TEST_F(GetTargetOutputsTest, SourceSet) {

- Target* source_set = new Target(setup_.settings(), GetLabel("//foo/", "bar"));

- source_set->set_output_type(Target::SOURCE_SET);

- items_.push_back(new scoped_ptr<Item>(source_set));

-

- Err err;

- Value result = GetTargetOutputs("//foo:bar", &err);

- ASSERT_FALSE(err.has_error());

- AssertSingleStringEquals(result, "//out/Debug/obj/foo/bar.stamp");

-}

-

- if (inputs.string_value() == "//foo")

- printf("foo\n");

-bool ReadString(Scope& scope, const char* var, std::string* dest, Err* err) {

- const Value* v = scope.GetValue(var, true);

-

- *dest = v->string_value();

-

- " tool(<command type>) { <command flags> }\n"

- "\n"

- " Used inside a toolchain definition to define a command to run for a\n"

- " given file type. See also \"gn help toolchain\".\n"

- "\n"

- "Command types\n"

- "\n"

- " The following values may be passed to the tool() function for the type\n"

- " of the command:\n"

- "\n"

- " \"cc\", \"cxx\", \"objc\", \"objcxx\", \"asm\", \"alink\", \"solink\",\n"

- " \"link\", \"stamp\", \"copy\"\n"

- "Tool-specific notes\n"

- " copy\n"

- " The copy command should be a native OS command since it does not\n"

- " implement toolchain dependencies (which would enable a copy tool to\n"

- " be compiled by a previous step).\n"

- " It is legal for the copy to not update the timestamp of the output\n"

- " file (as long as it's greater than or equal to the input file). This\n"

- " allows the copy command to be implemented as a hard link which can\n"

- " be more efficient.\n"

- "Command flags\n"

- " These variables may be specified in the { } block after the tool call.\n"

- " They are passed directly to Ninja. See the ninja documentation for how\n"

- " they work. Don't forget to backslash-escape $ required by Ninja to\n"

- " prevent GN from doing variable expansion.\n"

- " command, depfile, depsformat, description, pool, restat, rspfile,\n"

- " rspfile_content\n"

- " (Note that GN uses \"depsformat\" for Ninja's \"deps\" variable to\n"

- " avoid confusion with dependency lists.)\n"

- " Additionally, lib_prefix and lib_dir_prefix may be used for the link\n"

- " tools. These strings will be prepended to the libraries and library\n"

- " search directories, respectively, because linkers differ on how to\n"

- " specify them.\n"

- " Note: On Mac libraries with names ending in \".framework\" will be\n"

- " added to the link like with a \"-framework\" switch and the lib prefix\n"

- " will be ignored.\n"

- "Ninja variables available to tool invocations\n"

- " When writing tool commands, you use the various built-in Ninja\n"

- " variables like \"$in\" and \"$out\" (note that the $ must be escaped\n"

- " for it to be passed to Ninja, so write \"\\$in\" in the command\n"

- " string).\n"

- " GN defines the following variables for binary targets to access the\n"

- " various computed information needed for compiling:\n"

- "\n"

- " - Compiler flags: \"cflags\", \"cflags_c\", \"cflags_cc\",\n"

- " \"cflags_objc\", \"cflags_objcc\"\n"

- "\n"

- " - Linker flags: \"ldflags\", \"libs\"\n"

- "\n"

- " GN sets these other variables with target information that can be\n"

- " used for computing names for supplimetary files:\n"

- "\n"

- " - \"target_name\": The name of the current target with no\n"

- " path information. For example \"mylib\".\n"

- "\n"

- " - \"target_out_dir\": The value of \"target_out_dir\" from the BUILD\n"

- " file for this target (see \"gn help target_out_dir\"), relative\n"

- " to the root build directory with no trailing slash.\n"

- "\n"

- " - \"root_out_dir\": The value of \"root_out_dir\" from the BUILD\n"

- " file for this target (see \"gn help root_out_dir\"), relative\n"

- " to the root build directory with no trailing slash.\n"

- // Extract the stuff we need.

- Toolchain::Tool t;

- if (!ReadString(block_scope, "command", &t.command, err) ||

- !ReadString(block_scope, "depfile", &t.depfile, err) ||

- // TODO(brettw) delete this once we rename "deps" -> "depsformat" in

- // the toolchain definitions. This will avoid colliding with the

- // toolchain's "deps" list. For now, accept either.

- !ReadString(block_scope, "deps", &t.depsformat, err) ||

- !ReadString(block_scope, "depsformat", &t.depsformat, err) ||

- !ReadString(block_scope, "description", &t.description, err) ||

- !ReadString(block_scope, "lib_dir_prefix", &t.lib_dir_prefix, err) ||

- !ReadString(block_scope, "lib_prefix", &t.lib_prefix, err) ||

- !ReadString(block_scope, "pool", &t.pool, err) ||

- !ReadString(block_scope, "restat", &t.restat, err) ||

- !ReadString(block_scope, "rspfile", &t.rspfile, err) ||

- !ReadString(block_scope, "rspfile_content", &t.rspfile_content, err))

- toolchain->SetTool(tool_type, t);

- source_file.value(), args[0], err))

- 'ninja_helper.cc',

- 'ninja_helper.h',

- 'ninja_helper_unittest.cc',

- const Toolchain* toolchain,

- : NinjaTargetWriter(target, toolchain, out),

- for (size_t i = 0; i < output_files.size(); i++) {

- out_ << " ";

- path_output_.WriteFile(out_, output_files[i]);

- }

- WriteStamp(output_files);

- if (has_sources())

-void NinjaActionTargetWriter::WriteStamp(

- const std::vector<OutputFile>& output_files) {

- out_ << "build ";

- path_output_.WriteFile(out_, helper_.GetTargetOutputFile(target_));

- out_ << ": "

- << helper_.GetRulePrefix(target_->settings())

- << "stamp";

-

- // The action stamp depends on all output files from running the action.

- for (size_t i = 0; i < output_files.size(); i++) {

- out_ << " ";

- path_output_.WriteFile(out_, output_files[i]);

- }

-

- // It also depends on all datadeps. These are needed at runtime and should

- // be compiled when the action is, but don't need to be done before we run

- // the action.

- for (size_t i = 0; i < target_->datadeps().size(); i++) {

- out_ << " ";

- path_output_.WriteFile(out_,

- helper_.GetTargetOutputFile(target_->datadeps()[i].ptr));

- }

-

- out_ << std::endl;

-}

-

- NinjaActionTargetWriter(const Target* target,

- const Toolchain* toolchain,

- std::ostream& out);

- bool has_sources() const { return !target_->sources().empty(); }

-

- // Writes the .stamp rule that names this target and collects all invocations

- // of the script into one thing that other targets can depend on.

- void WriteStamp(const std::vector<OutputFile>& output_files);

-

- NinjaActionTargetWriter writer(&target, setup.toolchain(), out);

- NinjaActionTargetWriter writer(&target, setup.toolchain(), out);

- NinjaActionTargetWriter writer(&target, setup.toolchain(), out);

- NinjaActionTargetWriter writer(&target, setup.toolchain(), out);

- NinjaActionTargetWriter writer(&target, setup.toolchain(), out);

- "stamp input1.out input2.out obj/foo/datadep.stamp\n";

- NinjaActionTargetWriter writer(&target, setup.toolchain(), out);

- "stamp input1.out input2.out obj/foo/datadep.stamp\n";

- NinjaActionTargetWriter writer(&target, setup.toolchain(), out);

- NinjaActionTargetWriter writer(&target, setup.toolchain(), out);

- IncludeWriter(PathOutput& path_output, const NinjaHelper& h)

- : helper(h),

- path_output_(path_output) {

- const NinjaHelper& helper;

-Toolchain::ToolType GetToolTypeForTarget(const Target* target) {

- switch (target->output_type()) {

- case Target::STATIC_LIBRARY:

- return Toolchain::TYPE_ALINK;

- case Target::SHARED_LIBRARY:

- return Toolchain::TYPE_SOLINK;

- case Target::EXECUTABLE:

- return Toolchain::TYPE_LINK;

- default:

- return Toolchain::TYPE_NONE;

- }

-}

-

- const Toolchain* toolchain,

- : NinjaTargetWriter(target, toolchain, out),

- tool_type_(GetToolTypeForTarget(target)){

- out_ << "defines =";

- RecursiveTargetConfigToStream<std::string>(target_, &ConfigValues::defines,

- DefineWriter(), out_);

- out_ << std::endl;

- out_ << "includes =";

- RecursiveTargetConfigToStream<SourceDir>(target_, &ConfigValues::include_dirs,

- IncludeWriter(path_output_, helper_),

- out_);

-

- out_ << std::endl;

-#define WRITE_FLAGS(name) \

- out_ << #name " ="; \

- RecursiveTargetConfigStringsToStream(target_, &ConfigValues::name, \

- flag_escape_options, out_); \

- out_ << std::endl;

- WRITE_FLAGS(cflags)

- WRITE_FLAGS(cflags_c)

- WRITE_FLAGS(cflags_cc)

- WRITE_FLAGS(cflags_objc)

- WRITE_FLAGS(cflags_objcc)

- // Write some variables about the target for the toolchain definition to use.

- out_ << "target_name = " << target_->label().name() << std::endl;

- out_ << "target_out_dir = ";

- path_output_.WriteDir(out_, helper_.GetTargetOutputDir(target_),

- PathOutput::DIR_NO_LAST_SLASH);

- out_ << std::endl;

- out_ << "root_out_dir = ";

- path_output_.WriteDir(out_, target_->settings()->toolchain_output_subdir(),

- PathOutput::DIR_NO_LAST_SLASH);

- out_ << std::endl << std::endl;

- const SourceFile& input_file = sources[i];

-

- SourceFileType input_file_type = GetSourceFileType(input_file);

- if (input_file_type == SOURCE_UNKNOWN)

- continue; // Skip unknown file types.

- if (input_file_type == SOURCE_O) {

- // Object files just get passed to the output and not compiled.

- object_files->push_back(helper_.GetOutputFileForSource(

- target_, input_file, input_file_type));

- continue;

- std::string command =

- helper_.GetRuleForSourceType(settings_, input_file_type);

- if (command.empty())

- continue; // Skip files not needing compilation.

-

- OutputFile output_file = helper_.GetOutputFileForSource(

- target_, input_file, input_file_type);

- object_files->push_back(output_file);

-

- out_ << "build ";

- path_output_.WriteFile(out_, output_file);

- out_ << ": " << command << " ";

- path_output_.WriteFile(out_, input_file);

- out_ << implicit_deps << std::endl;

- // Manifest file on Windows.

- // TODO(brettw) this seems not to be necessary for static libs, skip in

- // that case?

- OutputFile windows_manifest;

- if (settings_->IsWin()) {

- windows_manifest = helper_.GetTargetOutputDir(target_);

- windows_manifest.value().append(target_->label().name());

- windows_manifest.value().append(".intermediate.manifest");

- out_ << "manifests = ";

- path_output_.WriteFile(out_, windows_manifest);

- out_ << std::endl;

- }

- const Toolchain::Tool& tool = toolchain_->GetTool(tool_type_);

- WriteLinkerFlags(tool, windows_manifest);

- WriteLibs(tool);

-

- // The external output file is the one that other libs depend on.

- OutputFile external_output_file = helper_.GetTargetOutputFile(target_);

-

- // The internal output file is the "main thing" we think we're making. In

- // the case of shared libraries, this is the shared library and the external

- // output file is the import library. In other cases, the internal one and

- // the external one are the same.

- OutputFile internal_output_file;

- if (target_->output_type() == Target::SHARED_LIBRARY) {

- if (settings_->IsWin()) {

- internal_output_file.value() =

- target_->settings()->toolchain_output_subdir().value();

- internal_output_file.value().append(target_->label().name());

- internal_output_file.value().append(".dll");

- } else {

- internal_output_file = external_output_file;

- }

- } else {

- internal_output_file = external_output_file;

- }

- // In Python see "self.ninja.build(output, command, input,"

- WriteLinkCommand(external_output_file, internal_output_file, object_files);

- if (target_->output_type() == Target::SHARED_LIBRARY) {

- // The shared object name doesn't include a path.

- out_ << " soname = ";

- out_ << FindFilename(&internal_output_file.value());

- out_ << std::endl;

- out_ << " lib = ";

- path_output_.WriteFile(out_, internal_output_file);

- out_ << std::endl;

- if (settings_->IsWin()) {

- out_ << " dll = ";

- path_output_.WriteFile(out_, internal_output_file);

- out_ << std::endl;

- }

- if (settings_->IsWin()) {

- out_ << " implibflag = /IMPLIB:";

- path_output_.WriteFile(out_, external_output_file);

- out_ << std::endl;

- // TODO(brettw) postbuild steps.

- if (settings_->IsMac())

- out_ << " postbuilds = $ && (export BUILT_PRODUCTS_DIR=/Users/brettw/prj/src/out/gn; export CONFIGURATION=Debug; export DYLIB_INSTALL_NAME_BASE=@rpath; export EXECUTABLE_NAME=libbase.dylib; export EXECUTABLE_PATH=libbase.dylib; export FULL_PRODUCT_NAME=libbase.dylib; export LD_DYLIB_INSTALL_NAME=@rpath/libbase.dylib; export MACH_O_TYPE=mh_dylib; export PRODUCT_NAME=base; export PRODUCT_TYPE=com.apple.product-type.library.dynamic; export SDKROOT=/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.7.sdk; export SRCROOT=/Users/brettw/prj/src/out/gn/../../base; export SOURCE_ROOT=\"$${SRCROOT}\"; export TARGET_BUILD_DIR=/Users/brettw/prj/src/out/gn; export TEMP_DIR=\"$${TMPDIR}\"; (cd ../../base && ../build/mac/strip_from_xcode); G=$$?; ((exit $$G) || rm -rf libbase.dylib) && exit $$G)";

-void NinjaBinaryTargetWriter::WriteLinkerFlags(

- const Toolchain::Tool& tool,

- const OutputFile& windows_manifest) {

- out_ << "ldflags =";

- out_ << " " << tool.lib_dir_prefix;

-

- // Append manifest flag on Windows to reference our file.

- // HACK ERASEME BRETTW FIXME

- if (settings_->IsWin()) {

- out_ << " /MANIFEST /ManifestFile:";

- path_output_.WriteFile(out_, windows_manifest);

- }

-void NinjaBinaryTargetWriter::WriteLibs(const Toolchain::Tool& tool) {

- out_ << "libs =";

- out_ << " " << tool.lib_prefix;

-void NinjaBinaryTargetWriter::WriteLinkCommand(

- const OutputFile& external_output_file,

- const OutputFile& internal_output_file,

- const std::vector<OutputFile>& object_files) {

- out_ << "build ";

- path_output_.WriteFile(out_, internal_output_file);

- if (external_output_file != internal_output_file) {

- out_ << " ";

- path_output_.WriteFile(out_, external_output_file);

- }

- out_ << ": "

- << helper_.GetRulePrefix(target_->settings())

- << Toolchain::ToolTypeToName(tool_type_);

-

- UniqueVector<OutputFile> extra_object_files;

- UniqueVector<const Target*> linkable_deps;

- UniqueVector<const Target*> non_linkable_deps;

- GetDeps(&extra_object_files, &linkable_deps, &non_linkable_deps);

-

- // Object files.

- for (size_t i = 0; i < object_files.size(); i++) {

- out_ << " ";

- path_output_.WriteFile(out_, object_files[i]);

- }

- for (size_t i = 0; i < extra_object_files.size(); i++) {

- out_ << " ";

- path_output_.WriteFile(out_, extra_object_files[i]);

- }

-

- // Libs.

- for (size_t i = 0; i < linkable_deps.size(); i++) {

- out_ << " ";

- path_output_.WriteFile(out_, helper_.GetTargetOutputFile(linkable_deps[i]));

- // Append data dependencies as implicit dependencies.

- WriteImplicitDependencies(non_linkable_deps);

- out_ << "build ";

- path_output_.WriteFile(out_, helper_.GetTargetOutputFile(target_));

- out_ << ": "

- << helper_.GetRulePrefix(target_->settings())

- << "stamp";

-

- for (size_t i = 0; i < object_files.size(); i++) {

- out_ << " ";

- path_output_.WriteFile(out_, object_files[i]);

- }

- // Append data dependencies as implicit dependencies.

- WriteImplicitDependencies(non_linkable_deps);

-

- out_ << std::endl;

- SourceFileType input_file_type = GetSourceFileType(dep->sources()[i]);

- if (input_file_type != SOURCE_UNKNOWN &&

- input_file_type != SOURCE_H) {

- // Note we need to specify the target as the source_set target

- // itself, since this is used to prefix the object file name.

- extra_object_files->push_back(helper_.GetOutputFileForSource(

- dep, dep->sources()[i], input_file_type));

-void NinjaBinaryTargetWriter::WriteImplicitDependencies(

- path_output_.WriteFile(out_,

- helper_.GetTargetOutputFile(non_linkable_deps[i]));

- // Data files.

- const std::vector<SourceFile>& data = target_->data();

- for (size_t i = 0; i < data.size(); i++) {

- out_ << " ";

- path_output_.WriteFile(out_, data[i]);

- }

- NinjaBinaryTargetWriter(const Target* target,

- const Toolchain* toolchain,

- std::ostream& out);

- void WriteLinkerFlags(const Toolchain::Tool& tool,

- const OutputFile& windows_manifest);

- void WriteLibs(const Toolchain::Tool& tool);

-

- // Writes the build line for linking the target. Includes newline.

- void WriteLinkCommand(const OutputFile& external_output_file,

- const OutputFile& internal_output_file,

- const std::vector<OutputFile>& object_files);

- // The implicit dependencies are the non-linkable deps passed in as an

- void WriteImplicitDependencies(

- Toolchain::ToolType tool_type_;

- NinjaBinaryTargetWriter writer(&target, setup.toolchain(), out);

- const char expected_win[] =

- "includes =\n"

- "target_name = bar\n"

- "target_out_dir = obj/foo\n"

- "build obj/foo/bar.input1.obj: cxx ../../foo/input1.cc\n"

- "build obj/foo/bar.input2.obj: cxx ../../foo/input2.cc\n"

- "build obj/foo/bar.stamp: stamp obj/foo/bar.input1.obj "

- "obj/foo/bar.input2.obj ../../foo/input3.o ../../foo/input4.obj\n";

-#if defined(OS_WIN)

- std::replace(out_str.begin(), out_str.end(), '\\', '/');

-#endif

- EXPECT_EQ(expected_win, out_str);

- NinjaBinaryTargetWriter writer(&shlib_target, setup.toolchain(), out);

- const char expected_win[] =

- "includes =\n"

- "target_name = shlib\n"

- "target_out_dir = obj/foo\n"

- "manifests = obj/foo/shlib.intermediate.manifest\n"

- "ldflags = /MANIFEST /ManifestFile:obj/foo/shlib.intermediate."

- "manifest\n"

- "libs =\n"

- "build shlib.dll shlib.dll.lib: solink obj/foo/bar.input1.obj "

- "obj/foo/bar.input2.obj ../../foo/input3.o "

- "../../foo/input4.obj\n"

- " soname = shlib.dll\n"

- " lib = shlib.dll\n"

- " dll = shlib.dll\n"

- " implibflag = /IMPLIB:shlib.dll.lib\n\n";

-#if defined(OS_WIN)

- std::replace(out_str.begin(), out_str.end(), '\\', '/');

-#endif

- EXPECT_EQ(expected_win, out_str);

- NinjaBinaryTargetWriter writer(&stlib_target, setup.toolchain(), out);

- const char expected_win[] =

- "includes =\n"

- "target_name = stlib\n"

- "target_out_dir = obj/foo\n"

- "manifests = obj/foo/stlib.intermediate.manifest\n"

- "ldflags = /MANIFEST /ManifestFile:obj/foo/stlib.intermediate.manifest\n"

- "libs =\n"

- // There are no sources so there are no params to alink.

- "build obj/foo/stlib.lib: alink\n\n";

-#if defined(OS_WIN)

- std::replace(out_str.begin(), out_str.end(), '\\', '/');

-#endif

- EXPECT_EQ(expected_win, out_str);

-

- NinjaBinaryTargetWriter writer(&target, setup.toolchain(), out);

- "includes =\n"

- "target_name = shlib\n"

- "target_out_dir = obj/foo\n"

- "build obj/foo/shlib.input1.o: cxx ../../foo/input1.cc\n"

- "build obj/foo/shlib.input2.o: cxx ../../foo/input2.cc\n"

- "ldflags =\n"

- "libs =\n"

- "build libshlib.so.6: solink obj/foo/shlib.input1.o "

- "obj/foo/shlib.input2.o\n"

- " soname = libshlib.so.6\n"

- " lib = libshlib.so.6\n"

- "\n";

-#if defined(OS_WIN)

- std::replace(out_str.begin(), out_str.end(), '\\', '/');

-#endif

- NinjaBinaryTargetWriter writer(&target, setup.toolchain(), out);

- "includes =\n"

- "target_name = shlib\n"

- "target_out_dir = obj/foo\n"

- "build obj/foo/shlib.input1.o: cxx ../../foo/input1.cc\n"

- "build obj/foo/shlib.input2.o: cxx ../../foo/input2.cc\n"

- "ldflags =\n"

- "libs =\n"

- "build libshlib.so: solink obj/foo/shlib.input1.o "

- "obj/foo/shlib.input2.o\n"

- " soname = libshlib.so\n"

- " lib = libshlib.so\n"

- "\n";

-#if defined(OS_WIN)

- std::replace(out_str.begin(), out_str.end(), '\\', '/');

-#endif

- path_output_(build_settings->build_dir(), ESCAPE_NINJA),

- helper_(build_settings) {

- path_output_.WriteFile(out_,

- helper_.GetNinjaFileForToolchain(all_settings_[i]));

- OutputFile target_file = helper_.GetTargetOutputFile(target);

- WritePhonyRule(target, helper_.GetTargetOutputFile(target),

-#include "tools/gn/ninja_helper.h"

- NinjaHelper helper_;

-

- const Toolchain* toolchain,

- : NinjaTargetWriter(target, toolchain, out) {

- std::vector<OutputFile> output_files;

-

- std::string rule_prefix = helper_.GetRulePrefix(target_->settings());

- output_files.push_back(output_file);

- out_ << ": " << rule_prefix << "copy ";

-

- // Write out the rule for the target to copy all of them.

- out_ << std::endl << "build ";

- path_output_.WriteFile(out_, helper_.GetTargetOutputFile(target_));

- out_ << ": " << rule_prefix << "stamp";

- for (size_t i = 0; i < output_files.size(); i++) {

- out_ << " ";

- path_output_.WriteFile(out_, output_files[i]);

- }

- out_ << std::endl;

- NinjaCopyTargetWriter(const Target* target,

- const Toolchain* toolchain,

- std::ostream& out);

- NinjaCopyTargetWriter writer(&target, setup.toolchain(), out);

- NinjaCopyTargetWriter writer(&target, setup.toolchain(), out);

- const Toolchain* toolchain,

- : NinjaTargetWriter(target, toolchain, out) {

- // the deps in the group.

- out_ << std::endl << "build ";

- path_output_.WriteFile(out_, helper_.GetTargetOutputFile(target_));

- out_ << ": "

- << helper_.GetRulePrefix(target_->settings())

- << "stamp";

-

- for (size_t i = 0; i < deps.size(); i++) {

- out_ << " ";

- path_output_.WriteFile(out_, helper_.GetTargetOutputFile(deps[i].ptr));

- }

- for (size_t i = 0; i < datadeps.size(); i++) {

- out_ << " ";

- path_output_.WriteFile(out_, helper_.GetTargetOutputFile(datadeps[i].ptr));

- }

- out_ << std::endl;

- NinjaGroupTargetWriter(const Target* target,

- const Toolchain* toolchain,

- std::ostream& out);

-// Copyright (c) 2013 The Chromium Authors. All rights reserved.

-// Use of this source code is governed by a BSD-style license that can be

-// found in the LICENSE file.

-

-#include "tools/gn/ninja_helper.h"

-

-#include "base/logging.h"

-#include "base/strings/string_util.h"

-#include "tools/gn/filesystem_utils.h"

-#include "tools/gn/string_utils.h"

-#include "tools/gn/target.h"

-

-namespace {

-

-const char kObjectDirNoSlash[] = "obj";

-

-} // namespace

-

-NinjaHelper::NinjaHelper(const BuildSettings* build_settings)

- : build_settings_(build_settings) {

- build_to_src_no_last_slash_ = build_settings->build_to_source_dir_string();

- if (!build_to_src_no_last_slash_.empty() &&

- build_to_src_no_last_slash_[build_to_src_no_last_slash_.size() - 1] ==

- '/')

- build_to_src_no_last_slash_.resize(build_to_src_no_last_slash_.size() - 1);

-

- build_to_src_system_no_last_slash_ = build_to_src_no_last_slash_;

-}

-

-NinjaHelper::~NinjaHelper() {

-}

-

-std::string NinjaHelper::GetTopleveOutputDir() const {

- return kObjectDirNoSlash;

-}

-

-OutputFile NinjaHelper::GetTargetOutputDir(const Target* target) const {

- OutputFile ret(target->settings()->toolchain_output_subdir());

- ret.value().append(kObjectDirNoSlash);

- AppendStringPiece(&ret.value(),

- target->label().dir().SourceAbsoluteWithOneSlash());

- return ret;

-}

-

-OutputFile NinjaHelper::GetNinjaFileForTarget(const Target* target) const {

- OutputFile ret = GetTargetOutputDir(target);

- ret.value().append(target->label().name());

- ret.value().append(".ninja");

- return ret;

-}

-

-OutputFile NinjaHelper::GetNinjaFileForToolchain(

- const Settings* settings) const {

- OutputFile ret;

- ret.value().append(settings->toolchain_output_subdir().value());

- ret.value().append("toolchain.ninja");

- return ret;

-}

-

-// In Python, GypPathToUniqueOutput does the qualification. The only case where

-// the Python version doesn't qualify the name is for target outputs, which we

-// handle in a separate function.

-OutputFile NinjaHelper::GetOutputFileForSource(

- const Target* target,

- const SourceFile& source,

- SourceFileType type) const {

- // Extract the filename and remove the extension (keep the dot).

- base::StringPiece filename = FindFilename(&source.value());

- std::string name(filename.data(), filename.size());

- size_t extension_offset = FindExtensionOffset(name);

- CHECK(extension_offset != std::string::npos);

- name.resize(extension_offset);

-

- // Append the new extension.

- switch (type) {

- case SOURCE_ASM:

- case SOURCE_C:

- case SOURCE_CC:

- case SOURCE_M:

- case SOURCE_MM:

- case SOURCE_S:

- name.append(target->settings()->IsWin() ? "obj" : "o");

- break;

-

- case SOURCE_RC:

- name.append("res");

- break;

-

- // Pass .o/.obj files through unchanged.

- case SOURCE_O: {

- // System-absolute file names get preserved (they don't need to be

- // rebased relative to the build dir).

- if (source.is_system_absolute())

- return OutputFile(source.value());

-

- // Files that are already inside the build dir should not be made

- // relative to the source tree. Doing so will insert an unnecessary

- // "../.." into the path which won't match the corresponding target

- // name in ninja.

- CHECK(build_settings_->build_dir().is_source_absolute());

- CHECK(source.is_source_absolute());

- if (StartsWithASCII(source.value(),

- build_settings_->build_dir().value(),

- true)) {

- return OutputFile(

- source.value().substr(

- build_settings_->build_dir().value().size()));

- }

-

- // Construct the relative location of the file from the build dir.

- OutputFile ret(build_to_src_no_last_slash());

- source.SourceAbsoluteWithOneSlash().AppendToString(&ret.value());

- return ret;

- }

-

- case SOURCE_H:

- case SOURCE_UNKNOWN:

- NOTREACHED();

- return OutputFile();

- }

-

- // Use the scheme <path>/<target>.<name>.<extension> so that all output

- // names are unique to different targets.

-

- // This will look like "obj" or "toolchain_name/obj".

- OutputFile ret(target->settings()->toolchain_output_subdir());

- ret.value().append(kObjectDirNoSlash);

-

- // Find the directory, assume it starts with two slashes, and trim to one.

- base::StringPiece dir = FindDir(&source.value());

- CHECK(dir.size() >= 2 && dir[0] == '/' && dir[1] == '/')

- << "Source file isn't in the source repo: " << dir;

- AppendStringPiece(&ret.value(), dir.substr(1));

-

- ret.value().append(target->label().name());

- ret.value().append(".");

- ret.value().append(name);

- return ret;

-}

-

-OutputFile NinjaHelper::GetTargetOutputFile(const Target* target) const {

- OutputFile ret;

-

- // Use the output name if given, fall back to target name if not.

- const std::string& name = target->output_name().empty() ?

- target->label().name() : target->output_name();

-

- // This is prepended to the output file name. Some platforms get "lib"

- // prepended to library names. but be careful not to make a duplicate (e.g.

- // some targets like "libxml" already have the "lib" in the name).

- const char* prefix;

- if (!target->settings()->IsWin() &&

- (target->output_type() == Target::SHARED_LIBRARY ||

- target->output_type() == Target::STATIC_LIBRARY) &&

- name.compare(0, 3, "lib") != 0)

- prefix = "lib";

- else

- prefix = "";

-

- const char* extension;

- if (target->output_extension().empty()) {

- if (target->output_type() == Target::GROUP ||

- target->output_type() == Target::SOURCE_SET ||

- target->output_type() == Target::COPY_FILES ||

- target->output_type() == Target::ACTION ||

- target->output_type() == Target::ACTION_FOREACH) {

- extension = "stamp";

- } else {

- extension = GetExtensionForOutputType(target->output_type(),

- target->settings()->target_os());

- }

- } else {

- extension = target->output_extension().c_str();

- }

-

- // Everything goes into the toolchain directory (which will be empty for the

- // default toolchain, and will end in a slash otherwise).

- ret.value().append(target->settings()->toolchain_output_subdir().value());

-

- // Binaries and shared libraries go into the toolchain root.

- if (target->output_type() == Target::EXECUTABLE ||

- target->output_type() == Target::SHARED_LIBRARY) {

- // Generate a name like "<toolchain>/<prefix><name>.<extension>".

- ret.value().append(prefix);

- ret.value().append(name);

- if (extension[0]) {

- ret.value().push_back('.');

- ret.value().append(extension);

- }

- return ret;

- }

-

- // Everything else goes next to the target's .ninja file like

- // "<toolchain>/obj/<path>/<name>.<extension>".

- ret.value().append(kObjectDirNoSlash);

- AppendStringPiece(&ret.value(),

- target->label().dir().SourceAbsoluteWithOneSlash());

- ret.value().append(prefix);

- ret.value().append(name);

- if (extension[0]) {

- ret.value().push_back('.');

- ret.value().append(extension);

- }

- return ret;

-}

-

-std::string NinjaHelper::GetRulePrefix(const Settings* settings) const {

- // Don't prefix the default toolchain so it looks prettier, prefix everything

- // else.

- if (settings->is_default())

- return std::string(); // Default toolchain has no prefix.

- return settings->toolchain_label().name() + "_";

-}

-

-std::string NinjaHelper::GetRuleForSourceType(const Settings* settings,

- SourceFileType type) const {

- // This function may be hot since it will be called for every source file

- // in the tree. We could cache the results to avoid making a string for

- // every invocation.

- std::string prefix = GetRulePrefix(settings);

-

- if (type == SOURCE_C)

- return prefix + "cc";

- if (type == SOURCE_CC)

- return prefix + "cxx";

- if (type == SOURCE_M)

- return prefix + "objc";

- if (type == SOURCE_MM)

- return prefix + "objcxx";

- if (type == SOURCE_RC)

- return prefix + "rc";

- if (type == SOURCE_S)

- return prefix + "cc"; // Assembly files just get compiled by CC.

-

- // TODO(brettw) asm files.

-

- // .obj files have no rules to make them (they're already built) so we return

- // the enpty string for SOURCE_O.

- return std::string();

-}

-// Copyright (c) 2013 The Chromium Authors. All rights reserved.

-// Use of this source code is governed by a BSD-style license that can be

-// found in the LICENSE file.

-

-#ifndef TOOLS_GN_NINJA_HELPER_H_

-#define TOOLS_GN_NINJA_HELPER_H_

-

-#include <iosfwd>

-#include <string>

-

-#include "tools/gn/filesystem_utils.h"

-#include "tools/gn/output_file.h"

-#include "tools/gn/target.h"

-

-class BuildSettings;

-class SourceDir;

-class SourceFile;

-class Target;

-

-// NinjaHelper -----------------------------------------------------------------

-

-class NinjaHelper {

- public:

- NinjaHelper(const BuildSettings* build_settings);

- ~NinjaHelper();

-

- // Ends in a slash.

- std::string GetTopleveOutputDir() const;

-

- // Ends in a slash.

- OutputFile GetTargetOutputDir(const Target* target) const;

-

- // Example: "base/base.ninja". The string version will not be escaped, and

- // will always have slashes for path separators.

- OutputFile GetNinjaFileForTarget(const Target* target) const;

-

- // Returns the name of the root .ninja file for the given toolchain.

- OutputFile GetNinjaFileForToolchain(const Settings* settings) const;

-

- // Given a source file relative to the source root, returns the output

- // filename.

- OutputFile GetOutputFileForSource(const Target* target,

- const SourceFile& source,

- SourceFileType type) const;

-

- // Returns the filename produced by the given output.

- //

- // Some targets make multiple files (like a .dll and an import library). This

- // function returns the name of the file other targets should depend on and

- // link to (so in this example, the import library).

- OutputFile GetTargetOutputFile(const Target* target) const;

-

- // Returns the prefix for rules on the given toolchain. We need this to

- // disambiguate a given rule for each toolchain.

- std::string GetRulePrefix(const Settings* settings) const;

-

- // Returns the name of the rule name for the given toolchain and file/target

- // type. Returns the empty string for source files with no command.

- std::string GetRuleForSourceType(const Settings* settings,

- SourceFileType type) const;

-

- // Returns the relative directory in either slashes or the system separator

- // from the ninja directory (e.g. "out/Debug") to the source root (e.g.

- // "../.."). It has no terminating slash.

- const std::string& build_to_src_no_last_slash() const {

- return build_to_src_no_last_slash_;

- }

- const std::string& build_to_src_system_no_last_slash() const {

- return build_to_src_system_no_last_slash_;

- }

-

- private:

- const BuildSettings* build_settings_;

-

- std::string build_to_src_no_last_slash_;

- std::string build_to_src_system_no_last_slash_;

-

- DISALLOW_COPY_AND_ASSIGN(NinjaHelper);

-};

-

-#endif // TOOLS_GN_NINJA_HELPER_H_

-// Copyright (c) 2013 The Chromium Authors. All rights reserved.

-// Use of this source code is governed by a BSD-style license that can be

-// found in the LICENSE file.

-

-#include "testing/gtest/include/gtest/gtest.h"

-

-#include "tools/gn/build_settings.h"

-#include "tools/gn/filesystem_utils.h"

-#include "tools/gn/ninja_helper.h"

-#include "tools/gn/settings.h"

-#include "tools/gn/target.h"

-#include "tools/gn/toolchain.h"

-

-namespace {

-

-class HelperSetterUpper {

- public:

- HelperSetterUpper()

- : build_settings(),

- settings(&build_settings, std::string()),

- toolchain(&settings, Label(SourceDir("//"), "tc")),

- target(&settings, Label(SourceDir("//tools/gn/"), "name")) {

- settings.set_toolchain_label(toolchain.label());

- settings.set_target_os(Settings::WIN);

-

- // Output going to "out/Debug".

- build_settings.SetBuildDir(SourceDir("//out/Debug/"));

-

- // Our source target is in "tools/gn".

- target.set_output_type(Target::EXECUTABLE);

- }

-

- BuildSettings build_settings;

- Settings settings;

- Toolchain toolchain;

- Target target;

-};

-

-} // namespace

-

-TEST(NinjaHelper, GetNinjaFileForTarget) {

- HelperSetterUpper setup;

- NinjaHelper helper(&setup.build_settings);

-

- // Default toolchain.

- EXPECT_EQ(OutputFile("obj/tools/gn/name.ninja").value(),

- helper.GetNinjaFileForTarget(&setup.target).value());

-}

-

-TEST(NinjaHelper, GetOutputFileForSource) {

- HelperSetterUpper setup;

- NinjaHelper helper(&setup.build_settings);

-

- // On Windows, expect ".obj"

- EXPECT_EQ(OutputFile("obj/tools/gn/name.foo.obj").value(),

- helper.GetOutputFileForSource(&setup.target,

- SourceFile("//tools/gn/foo.cc"),

- SOURCE_CC).value());

-}

-

-TEST(NinjaHelper, GetOutputFileForObject) {

- HelperSetterUpper setup;

- NinjaHelper helper(&setup.build_settings);

-

- EXPECT_EQ(OutputFile("../../tools/gn/foo.o").value(),

- helper.GetOutputFileForSource(&setup.target,

- SourceFile("//tools/gn/foo.o"),

- SOURCE_O).value());

-

- EXPECT_EQ(OutputFile("../../tools/gn/foo.obj").value(),

- helper.GetOutputFileForSource(&setup.target,

- SourceFile("//tools/gn/foo.obj"),

- SOURCE_O).value());

-

- EXPECT_EQ(OutputFile("nested/foo.o").value(),

- helper.GetOutputFileForSource(

- &setup.target,

- SourceFile("//out/Debug/nested/foo.o"),

- SOURCE_O).value());

-

- EXPECT_EQ(OutputFile("/abs/rooted/foo.o").value(),

- helper.GetOutputFileForSource(&setup.target,

- SourceFile("/abs/rooted/foo.o"),

- SOURCE_O).value());

-}

-

-TEST(NinjaHelper, GetTargetOutputFile) {

- HelperSetterUpper setup;

- NinjaHelper helper(&setup.build_settings);

- EXPECT_EQ(OutputFile("name.exe"),

- helper.GetTargetOutputFile(&setup.target));

-

- // Static library on Windows goes alongside the object files.

- setup.target.set_output_type(Target::STATIC_LIBRARY);

- EXPECT_EQ(OutputFile("obj/tools/gn/name.lib"),

- helper.GetTargetOutputFile(&setup.target));

-

- // TODO(brettw) test output to library and other OS types.

-}

- const Toolchain* toolchain,

- toolchain_(toolchain),

- path_output_(settings_->build_settings()->build_dir(), ESCAPE_NINJA),

- helper_(settings_->build_settings()) {

-void NinjaTargetWriter::RunAndWriteFile(const Target* target,

- const Toolchain* toolchain) {

- NinjaHelper helper(settings->build_settings());

- helper.GetNinjaFileForTarget(target).GetSourceFile(

- settings->build_settings())));

- NinjaCopyTargetWriter writer(target, toolchain, file);

- NinjaActionTargetWriter writer(target, toolchain, file);

- NinjaGroupTargetWriter writer(target, toolchain, file);

- NinjaBinaryTargetWriter writer(target, toolchain, file);

- toolchain_->deps().empty())

- OutputFile input_stamp_file = helper_.GetTargetOutputDir(target_);

- out_ << "build " << stamp_file_string << ": " +

- helper_.GetRulePrefix(settings_) + "stamp";

- // Add on any hard deps that are direct or indirect dependencies.

- out_ << " ";

- path_output_.WriteFile(out_, helper_.GetTargetOutputFile(*i));

- const LabelTargetVector& toolchain_deps = toolchain_->deps();

- for (size_t i = 0; i < toolchain_deps.size(); i++) {

- out_ << " ";

- path_output_.WriteFile(out_,

- helper_.GetTargetOutputFile(toolchain_deps[i].ptr));

- }

- // Extra hard deps passed in.

- for (size_t i = 0; i < extra_hard_deps.size(); i++) {

- path_output_.WriteFile(out_,

- helper_.GetTargetOutputFile(extra_hard_deps[i]));

-#include "tools/gn/ninja_helper.h"

- NinjaTargetWriter(const Target* target,

- const Toolchain* toolchain,

- std::ostream& out);

- static void RunAndWriteFile(const Target* target, const Toolchain* toolchain);

- const Toolchain* toolchain_; // Non-owning.

- NinjaHelper helper_;

-

- : NinjaTargetWriter(target, toolchain, out) {

- path_output_(settings_->build_settings()->build_dir(), ESCAPE_NINJA),

- helper_(settings->build_settings()) {

- NinjaHelper helper(settings->build_settings());

- helper.GetNinjaFileForToolchain(settings).GetSourceFile(

- settings->build_settings())));

- std::string indent(" ");

-

- NinjaHelper helper(settings_->build_settings());

- std::string rule_prefix = helper.GetRulePrefix(settings_);

- const Toolchain::Tool& tool = toolchain_->GetTool(tool_type);

- if (tool.command.empty())

- continue;

-

- out_ << "rule " << rule_prefix << Toolchain::ToolTypeToName(tool_type)

- << std::endl;

-

- #define WRITE_ARG(name) \

- if (!tool.name.empty()) \

- out_ << indent << " " STRINGIZE(name) " = " << tool.name << std::endl;

- WRITE_ARG(command);

- WRITE_ARG(depfile);

- WRITE_ARG(description);

- WRITE_ARG(pool);

- WRITE_ARG(restat);

- WRITE_ARG(rspfile);

- WRITE_ARG(rspfile_content);

- #undef WRITE_ARG

-

- // Deps is called "depsformat" in GN to avoid confusion with dependencies.

- if (!tool.depsformat.empty()) \

- out_ << indent << " deps = " << tool.depsformat << std::endl;

- OutputFile ninja_file = helper_.GetNinjaFileForTarget(targets_[i]);

-#include "tools/gn/ninja_helper.h"

-class Toolchain;

- NinjaHelper helper_;

-

-#include "tools/gn/source_file.h"

- OutputFile() : value_() {}

- explicit OutputFile(const base::StringPiece& str)

- : value_(str.data(), str.size()) {

- }

- SourceFile GetSourceFile(const BuildSettings* build_settings) const {

- return SourceFile(build_settings->build_dir().value() + value_);

- }

- FillRequiredTypes();

- FillRequiredTypes();

-void SubstitutionList::FillRequiredTypes() {

- bool required_type_bits[SUBSTITUTION_NUM_TYPES];

- memset(&required_type_bits, 0, SUBSTITUTION_NUM_TYPES);

- list_[i].FillRequiredTypes(required_type_bits);

-

- for (size_t i = SUBSTITUTION_FIRST_PATTERN; i < SUBSTITUTION_NUM_TYPES; i++) {

- if (required_type_bits[i])

- required_types_.push_back(static_cast<SubstitutionType>(i));

- }

- private:

- void FillRequiredTypes();

-SubstitutionPattern::SubstitutionPattern() {

- // Fill required types vector.

- bool required_type_bits[SUBSTITUTION_NUM_TYPES] = {0};

- FillRequiredTypes(required_type_bits);

- for (size_t i = SUBSTITUTION_FIRST_PATTERN; i < SUBSTITUTION_NUM_TYPES; i++) {

- if (required_type_bits[i])

- required_types_.push_back(static_cast<SubstitutionType>(i));

- }

-void SubstitutionPattern::FillRequiredTypes(

- bool required_types[SUBSTITUTION_NUM_TYPES]) const {

- required_types[static_cast<size_t>(ranges_[i].type)] = true;

- void FillRequiredTypes(bool required_types[SUBSTITUTION_NUM_TYPES]) const;

- NULL, // SUBSTITUTION_LITERAL

- "{{output}}", // SUBSTITUTION_OUTPUT

- // This isn't written by GN, the name here is referring to the Ninja variable

- // since when we would use this would be for writing source rules.

- "output", // SUBSTITUTION_OUTPUT

- "inputs", // SUBSTITUTION_LINKER_INPUTS

- type == SUBSTITUTION_SOURCE_OUT_DIR;

- return type == SUBSTITUTION_SOURCE ||

- return type == SUBSTITUTION_OUTPUT ||

- return IsValidToolSubstutition(type) &&

- type != SUBSTITUTION_OUTPUT;

- // Valid for all compiler and linker tools (depends on target).

- SUBSTITUTION_OUTPUT, // {{output}}

-SubstitutionWriter::SubstitutionWriter() {

-}

-SubstitutionWriter::~SubstitutionWriter() {

- const Settings* settings,

- GetListAsSourceFiles(settings, list, &output_as_sources);

- output->push_back(OutputFile(

- RebaseSourceAbsolutePath(output_as_sources[i].value(),

- settings->build_settings()->build_dir())));

- return OutputFile(

- RebaseSourceAbsolutePath(result_as_source.value(),

- settings->build_settings()->build_dir()));

-void SubstitutionWriter::WriteWithNinjaVariables(

- const SubstitutionPattern& pattern,

- const EscapeOptions& escape_options,

- std::ostream& out) {

- // The result needs to be quoted as if it was one string, but the $ for

- // the inserted Ninja variables can't be escaped. So write to a buffer with

- // no quoting, and then quote the whole thing if necessary.

- EscapeOptions no_quoting(escape_options);

- no_quoting.inhibit_quoting = true;

-

- bool needs_quotes = false;

- std::string result;

- for (size_t i = 0; i < pattern.ranges().size(); i++) {

- const SubstitutionPattern::Subrange range = pattern.ranges()[i];

- if (range.type == SUBSTITUTION_LITERAL) {

- result.append(EscapeString(range.literal, no_quoting, &needs_quotes));

- } else {

- result.append("${");

- result.append(kSubstitutionNinjaNames[range.type]);

- result.append("}");

- }

- }

-

- if (needs_quotes && !escape_options.inhibit_quoting)

- out << "\"" << result << "\"";

- else

- out << result;

-}

-

-// static

- NOTREACHED();

- SubstitutionWriter();

- ~SubstitutionWriter();

- const Settings* settings,

- // Writes the pattern to the given stream with no special handling, and with

- // Ninja variables replacing the patterns.

- static void WriteWithNinjaVariables(

- const SubstitutionPattern& pattern,

- const EscapeOptions& escape_options,

- std::ostream& out);

-

-// Tests in isolation different types of substitutions and that the right

-// things are generated.

-TEST(SubstutitionWriter, Substitutions) {

- hard_dep_(false) {

- pattern.ranges()[0].literal, original_value, err_))

-namespace {

-

-class TargetTest : public testing::Test {

- public:

- TargetTest()

- : build_settings_(),

- settings_(&build_settings_, std::string()),

- toolchain_(&settings_, Label(SourceDir("//tc/"), "tc")) {

- settings_.set_toolchain_label(toolchain_.label());

- }

- virtual ~TargetTest() {

- }

-

- protected:

- BuildSettings build_settings_;

- Settings settings_;

- Toolchain toolchain_;

-};

-

-} // namespace

-

-TEST_F(TargetTest, GroupDeps) {

- Target x(&settings_, Label(SourceDir("//component/"), "x"));

- Target y(&settings_, Label(SourceDir("//component/"), "y"));

- Target g(&settings_, Label(SourceDir("//group/"), "g"));

- Target b(&settings_, Label(SourceDir("//app/"), "b"));

- Target a(&settings_, Label(SourceDir("//app/"), "a"));

-TEST_F(TargetTest, LibInheritance) {

- Target z(&settings_, Label(SourceDir("//foo/"), "z"));

- Target shared(&settings_, Label(SourceDir("//foo/"), "shared"));

- Target exec(&settings_, Label(SourceDir("//foo/"), "exec"));

-TEST_F(TargetTest, DependentConfigs) {

- Target a(&settings_, Label(SourceDir("//foo/"), "a"));

- Target b(&settings_, Label(SourceDir("//foo/"), "b"));

- Target c(&settings_, Label(SourceDir("//foo/"), "c"));

- Config config(&settings_, Label(SourceDir("//foo/"), "config"));

- Config all(&settings_, Label(SourceDir("//foo/"), "all"));

- Config direct(&settings_, Label(SourceDir("//foo/"), "direct"));

- Target a_fwd(&settings_, Label(SourceDir("//foo/"), "a_fwd"));

- Target b_fwd(&settings_, Label(SourceDir("//foo/"), "b_fwd"));

-TEST_F(TargetTest, ForwardDependentConfigsFromGroups) {

- Target a(&settings_, Label(SourceDir("//foo/"), "a"));

- Target b(&settings_, Label(SourceDir("//foo/"), "b"));

- Target c(&settings_, Label(SourceDir("//foo/"), "c"));

- Config direct(&settings_, Label(SourceDir("//foo/"), "direct"));

-TEST_F(TargetTest, InheritLibs) {

- Target a(&settings_, Label(SourceDir("//foo/"), "a"));

- Target b(&settings_, Label(SourceDir("//foo/"), "b"));

- Target c(&settings_, Label(SourceDir("//foo/"), "c"));

- Target d(&settings_, Label(SourceDir("//foo/"), "d"));