Add initial prototype for the GN meta-buildsystem.
This is currently not hooked into the build. To build, add a reference to the
gn.gyp file to build/all.gyp
R=darin@chromium.org, scottmg@chromium.org
Review URL: https://codereview.chromium.org/21114002
Cr-Mirrored-From: https://chromium.googlesource.com/chromium/src
Cr-Mirrored-Commit: c88bd8f2c08838c6730b946dc4a50d4386ef43f9
diff --git a/tools/gn/BUILD.gn b/tools/gn/BUILD.gn
new file mode 100644
index 0000000..ccb5411
--- /dev/null
+++ b/tools/gn/BUILD.gn
@@ -0,0 +1,153 @@
+static_library("gn_lib") {
+ sources = [
+ "build_settings.cc",
+ "build_settings.h",
+ "command_desc.cc",
+ "command_desc.h",
+ "command_gen.cc",
+ "command_gen.h",
+ "command.cc",
+ "config.cc",
+ "config.h",
+ "config_values.h",
+ "config_values_extractors.cc",
+ "config_values_extractors.h",
+ "config_values_generator.cc",
+ "config_values_generator.h",
+ "err.cc",
+ "err.h",
+ "escape.cc",
+ "escape.h",
+ "file_template.cc",
+ "file_template.h",
+ "filesystem_utils.cc",
+ "filesystem_utils.h",
+ "functions.cc",
+ "functions.h",
+ "functions_target.cc",
+ "function_exec_script.cc",
+ "function_process_file_template.cc",
+ "function_read_file.cc",
+ "function_set_default_toolchain.cc",
+ "function_template.cc",
+ "function_toolchain.cc",
+ "function_write_file.cc",
+ "import_manager.cc",
+ "import_manager.h",
+ "input_conversion.cc",
+ "input_conversion.h",
+ "input_file.cc",
+ "input_file.h",
+ "input_file_manager.cc",
+ "input_file_manager.h",
+ "item.cc",
+ "item.h",
+ "item_node.cc",
+ "item_node.h",
+ "item_tree.cc",
+ "item_tree.h",
+ "label.cc",
+ "label.h",
+ "location.h",
+ "ninja_build_writer.cc",
+ "ninja_build_writer.h",
+ "ninja_helper.cc",
+ "ninja_helper.h",
+ "ninja_target_writer.cc",
+ "ninja_target_writer.h",
+ "ninja_toolchain_writer.cc",
+ "ninja_toolchain_writer.h",
+ "ninja_writer.cc",
+ "ninja_writer.h",
+ "operators.cc",
+ "operators.h",
+ "output_file.h",
+ "parse_tree.cc",
+ "parse_tree.h",
+ "parser.cc",
+ "parser.h",
+ "path_output.cc",
+ "path_output.h",
+ "pattern.cc",
+ "pattern.h",
+ "scheduler.cc",
+ "scheduler.h",
+ "scope.cc",
+ "scope.h",
+ "scope_per_file_provider.cc",
+ "scope_per_file_provider.h",
+ "settings.cc",
+ "settings.h",
+ "setup.cc",
+ "setup.h",
+ "source_dir.cc",
+ "source_dir.h",
+ "source_file.cc",
+ "source_file.h",
+ "standard_out.cc",
+ "standard_out.h",
+ "string_utils.cc",
+ "string_utils.h",
+ "target.cc",
+ "target.h",
+ "target_generator.cc",
+ "target_generator.h",
+ "target_manager.cc",
+ "target_manager.h",
+ "token.cc",
+ "token.h",
+ "tokenizer.cc",
+ "tokenizer.h",
+ "toolchain.cc",
+ "toolchain.h",
+ "toolchain_manager.cc",
+ "toolchain_manager.h",
+ "value.cc",
+ "value.h",
+ "value_extractors.cc",
+ "value_extractors.h",
+ ]
+ deps = [
+ "//base",
+ "//base/third_party/dynamic_annotations",
+ ]
+}
+
+executable("gn") {
+ sources = [
+ "gn_main.cc",
+ ]
+ deps = [
+ ":gn_lib",
+ ]
+}
+
+test("gn_unittests") {
+ sources = [
+ "escape_unittest.cc",
+ "file_template_unittest.cc",
+ "filesystem_utils_unittest.cc",
+ "input_conversion_unittest.cc",
+ "label_unittest.cc",
+ "ninja_helper_unittest.cc",
+ "parser_unittest.cc",
+ "path_output_unittest.cc",
+ "pattern_unittest.cc",
+ "source_dir_unittest.cc",
+ "string_utils_unittest.cc",
+ "target_generator_unittest.cc",
+ "target_manager_unittest.cc",
+ "tokenizer_unittest.cc",
+ ]
+ deps = [
+ ":gn_lib",
+ "//base:run_all_unittests",
+ "//base:test_support_base",
+ "//testing:gtest",
+ ]
+}
+
+executable("generate_test_gn_data") {
+ sources = [ "generate_test_gn_data.cc" ]
+ deps = [ "//base" ]
+}
diff --git a/tools/gn/OWNERS b/tools/gn/OWNERS
new file mode 100644
index 0000000..06fefbf
--- /dev/null
+++ b/tools/gn/OWNERS
@@ -0,0 +1 @@
+brettw@chromium.org
diff --git a/tools/gn/README.txt b/tools/gn/README.txt
new file mode 100644
index 0000000..0a637bf
--- /dev/null
+++ b/tools/gn/README.txt
@@ -0,0 +1,7 @@
+GN "Generate Ninja"
+
+This tool is an experimental metabuildsystem. It is not currently in a state
+where it is ready for public consumption.
+
+It is not currently used in the build and there are currently no plans to
+replace GYP.
diff --git a/tools/gn/build_settings.cc b/tools/gn/build_settings.cc
new file mode 100644
index 0000000..09b4c99
--- /dev/null
+++ b/tools/gn/build_settings.cc
@@ -0,0 +1,44 @@
+// 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/build_settings.h"
+
+#include "tools/gn/filesystem_utils.h"
+
+BuildSettings::BuildSettings()
+ : item_tree_(),
+ target_manager_(this),
+ toolchain_manager_(this) {
+}
+
+BuildSettings::~BuildSettings() {
+}
+
+void BuildSettings::SetSecondarySourcePath(const SourceDir& d) {
+ secondary_source_path_ = GetFullPath(d);
+}
+
+void BuildSettings::SetBuildDir(const SourceDir& d) {
+ build_dir_ = d;
+ build_to_source_dir_string_ = InvertDir(d);
+}
+
+base::FilePath BuildSettings::GetFullPath(const SourceFile& file) const {
+ return file.Resolve(root_path_);
+}
+
+base::FilePath BuildSettings::GetFullPath(const SourceDir& dir) const {
+ return dir.Resolve(root_path_);
+}
+
+base::FilePath BuildSettings::GetFullPathSecondary(
+ const SourceFile& file) const {
+ return file.Resolve(secondary_source_path_);
+}
+
+base::FilePath BuildSettings::GetFullPathSecondary(
+ const SourceDir& dir) const {
+ return dir.Resolve(secondary_source_path_);
+}
+
diff --git a/tools/gn/build_settings.h b/tools/gn/build_settings.h
new file mode 100644
index 0000000..fe04266
--- /dev/null
+++ b/tools/gn/build_settings.h
@@ -0,0 +1,110 @@
+// 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_BUILD_SETTINGS_H_
+#define TOOLS_GN_BUILD_SETTINGS_H_
+
+#include "base/basictypes.h"
+#include "base/callback.h"
+#include "base/files/file_path.h"
+#include "tools/gn/item_tree.h"
+#include "tools/gn/scope.h"
+#include "tools/gn/source_dir.h"
+#include "tools/gn/source_file.h"
+#include "tools/gn/target_manager.h"
+#include "tools/gn/toolchain_manager.h"
+
+// Settings for one build, which is one toplevel output directory. There
+// may be multiple Settings objects that refer to this, one for each toolchain.
+class BuildSettings {
+ public:
+ typedef base::Callback<void(const Target*)> TargetResolvedCallback;
+
+ BuildSettings();
+ ~BuildSettings();
+
+ // Absolute path of the source root on the local system. Everything is
+ // relative to this.
+ const base::FilePath& root_path() const { return root_path_; }
+ void set_root_path(const base::FilePath& r) { root_path_ = r; }
+
+ // When nonempty, specifies a parallel directory higherarchy in which to
+ // search for buildfiles if they're not found in the root higherarchy. This
+ // allows us to keep buildfiles in a separate tree during development.
+ const base::FilePath& secondary_source_path() const {
+ return secondary_source_path_;
+ }
+ void SetSecondarySourcePath(const SourceDir& d);
+
+ // Path of the python executable to run scripts with.
+ base::FilePath python_path() const { return python_path_; }
+ void set_python_path(const base::FilePath& p) { python_path_ = p; }
+
+ const SourceFile& build_config_file() const { return build_config_file_; }
+ void set_build_config_file(const SourceFile& f) { build_config_file_ = f; }
+
+ // The build directory is the root of all output files. The default toolchain
+ // files go into here, and non-default toolchains will have separate
+ // toolchain-specific root directories inside this.
+ const SourceDir& build_dir() const { return build_dir_; }
+ void SetBuildDir(const SourceDir& dir);
+
+ // The inverse of relative_build_dir, ending with a separator.
+ // Example: relative_build_dir_ = "out/Debug/" this will be "../../"
+ const std::string& build_to_source_dir_string() const {
+ return build_to_source_dir_string_;
+ }
+
+ // These accessors do not return const objects since the resulting objects
+ // are threadsafe. In this setting, we use constness primarily to ensure
+ // that the Settings object is used in a threadsafe manner. Although this
+ // violates the concept of logical constness, that's less important in our
+ // application, and actually implementing this in a way that preserves
+ // logical constness is cumbersome.
+ ItemTree& item_tree() const { return item_tree_; }
+ TargetManager& target_manager() const { return target_manager_; }
+ ToolchainManager& toolchain_manager() const { return toolchain_manager_; }
+
+ // Returns the full absolute OS path cooresponding to the given file in the
+ // root source tree.
+ base::FilePath GetFullPath(const SourceFile& file) const;
+ base::FilePath GetFullPath(const SourceDir& dir) const;
+
+ // Returns the absolute OS path inside the secondary source path. Will return
+ // an empty FilePath if the secondary source path is empty. When loading a
+ // buildfile, the GetFullPath should always be consulted first.
+ base::FilePath GetFullPathSecondary(const SourceFile& file) const;
+ base::FilePath GetFullPathSecondary(const SourceDir& dir) const;
+
+ // This is the callback to execute when a target is marked resolved. If we
+ // don't need to do anything, this will be null. When a target is resolved,
+ // this callback should be posted to the scheduler pool so the work is
+ // distributed properly.
+ const TargetResolvedCallback& target_resolved_callback() const {
+ return target_resolved_callback_;
+ }
+ void set_target_resolved_callback(const TargetResolvedCallback& cb) {
+ target_resolved_callback_ = cb;
+ }
+
+ private:
+ base::FilePath root_path_;
+ base::FilePath secondary_source_path_;
+ base::FilePath python_path_;
+
+ SourceFile build_config_file_;
+ SourceDir build_dir_;
+ std::string build_to_source_dir_string_;
+
+ TargetResolvedCallback target_resolved_callback_;
+
+ // See getters above.
+ mutable ItemTree item_tree_;
+ mutable TargetManager target_manager_;
+ mutable ToolchainManager toolchain_manager_;
+
+ DISALLOW_COPY_AND_ASSIGN(BuildSettings);
+};
+
+#endif // TOOLS_GN_BUILD_SETTINGS_H_
diff --git a/tools/gn/command_desc.cc b/tools/gn/command_desc.cc
new file mode 100644
index 0000000..bf91776
--- /dev/null
+++ b/tools/gn/command_desc.cc
@@ -0,0 +1,201 @@
+// 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 <algorithm>
+#include <set>
+
+#include "tools/gn/commands.h"
+#include "tools/gn/config.h"
+#include "tools/gn/item.h"
+#include "tools/gn/item_node.h"
+#include "tools/gn/label.h"
+#include "tools/gn/setup.h"
+#include "tools/gn/standard_out.h"
+#include "tools/gn/target.h"
+
+namespace {
+
+struct CompareTargetLabel {
+ bool operator()(const Target* a, const Target* b) const {
+ return a->label() < b->label();
+ }
+};
+
+const Target* GetTargetForDesc(const std::vector<std::string>& args) {
+ // Deliberately leaked to avoid expensive process teardown.
+ Setup* setup = new Setup;
+ if (!setup->DoSetup())
+ return NULL;
+
+ // FIXME(brettw): set the output dir to be a sandbox one to avoid polluting
+ // the real output dir with files written by the build scripts.
+
+ // Do the actual load. This will also write out the target ninja files.
+ if (!setup->Run())
+ return NULL;
+
+ // Need to resolve the label after we know the default toolchain.
+ // TODO(brettw) find the current directory and resolve the input label
+ // relative to that.
+ Label default_toolchain = setup->build_settings().toolchain_manager()
+ .GetDefaultToolchainUnlocked();
+ Value arg_value(NULL, args[0]);
+ Err err;
+ Label label = Label::Resolve(SourceDir(), default_toolchain, arg_value, &err);
+ if (err.has_error()) {
+ err.PrintToStdout();
+ return NULL;
+ }
+
+ ItemNode* node;
+ {
+ base::AutoLock lock(setup->build_settings().item_tree().lock());
+ node = setup->build_settings().item_tree().GetExistingNodeLocked(label);
+ }
+ if (!node) {
+ Err(Location(), "",
+ "I don't know about this \"" + label.GetUserVisibleName(false) +
+ "\"").PrintToStdout();
+ return NULL;
+ }
+
+ const Target* target = node->item()->AsTarget();
+ if (!target) {
+ Err(Location(), "Not a target.",
+ "The \"" + label.GetUserVisibleName(false) + "\" thing\n"
+ "is not a target. Somebody should probably implement this command for "
+ "other\nitem types.");
+ return NULL;
+ }
+
+ return target;
+}
+
+void RecursiveCollectDeps(const Target* target, std::set<Label>* result) {
+ if (result->find(target->label()) != result->end())
+ return; // Already did this target.
+ result->insert(target->label());
+
+ const std::vector<const Target*>& deps = target->deps();
+ for (size_t i = 0; i < deps.size(); i++)
+ RecursiveCollectDeps(deps[i], result);
+}
+
+// Prints dependencies of the given target (not the target itself).
+void RecursivePrintDeps(const Target* target,
+ const Label& default_toolchain,
+ int indent_level) {
+ std::vector<const Target*> sorted_deps = target->deps();
+ std::sort(sorted_deps.begin(), sorted_deps.end(), CompareTargetLabel());
+
+ std::string indent(indent_level * 2, ' ');
+ for (size_t i = 0; i < sorted_deps.size(); i++) {
+ OutputString(indent +
+ sorted_deps[i]->label().GetUserVisibleName(default_toolchain) + "\n");
+ RecursivePrintDeps(sorted_deps[i], default_toolchain, indent_level + 1);
+ }
+}
+
+} // namespace
+
+int RunDescCommand(const std::vector<std::string>& args) {
+ if (args.size() != 1) {
+ Err(Location(), "You're holding it wrong.",
+ "Usage: \"gn desc <target_name>\"").PrintToStdout();
+ return NULL;
+ }
+
+ const Target* target = GetTargetForDesc(args);
+ if (!target)
+ return 1;
+
+ // Generally we only want to display toolchains on labels when the toolchain
+ // is different than the default one for this target (which we always print
+ // in the header).
+ Label target_toolchain = target->label().GetToolchainLabel();
+
+ // Header.
+ std::string title_target =
+ "Target: " + target->label().GetUserVisibleName(false);
+ std::string title_toolchain =
+ "Toolchain: " + target_toolchain.GetUserVisibleName(false);
+ OutputString(title_target + "\n", DECORATION_YELLOW);
+ OutputString(title_toolchain + "\n", DECORATION_YELLOW);
+ OutputString(std::string(
+ std::max(title_target.size(), title_toolchain.size()), '=') + "\n");
+
+ OutputString("Sources:\n");
+ const Target::FileList& sources = target->sources();
+ for (size_t i = 0; i < sources.size(); i++)
+ OutputString(" " + sources[i].value() + "\n");
+
+ // Configs (don't sort since the order determines how things are processed).
+ OutputString("\nConfigs:\n");
+ const std::vector<const Config*>& configs = target->configs();
+ for (size_t i = 0; i < configs.size(); i++) {
+ OutputString(" " +
+ configs[i]->label().GetUserVisibleName(target_toolchain) + "\n");
+ }
+
+ // Deps. Sorted for convenience. Sort the labels rather than the strings so
+ // that "//foo:bar" comes before "//foo/third_party:bar".
+ OutputString("\nDirect dependencies:\n"
+ "(Use \"gn deps\" or \"gn tree\" to display recursive deps.)\n");
+ const std::vector<const Target*>& deps = target->deps();
+ std::vector<Label> sorted_deps;
+ for (size_t i = 0; i < deps.size(); i++)
+ sorted_deps.push_back(deps[i]->label());
+ std::sort(sorted_deps.begin(), sorted_deps.end());
+ for (size_t i = 0; i < sorted_deps.size(); i++) {
+ OutputString(" " + sorted_deps[i].GetUserVisibleName(target_toolchain) +
+ "\n");
+ }
+ return 0;
+}
+
+int RunDepsCommand(const std::vector<std::string>& args) {
+ if (args.size() != 1) {
+ Err(Location(), "You're holding it wrong.",
+ "Usage: \"gn deps <target_name>\"").PrintToStdout();
+ return NULL;
+ }
+
+ const Target* target = GetTargetForDesc(args);
+ if (!target)
+ return 1;
+
+ // Generally we only want to display toolchains on labels when the toolchain
+ // is different than the default one for this target (which we always print
+ // in the header).
+ Label target_toolchain = target->label().GetToolchainLabel();
+
+ std::set<Label> all_deps;
+ RecursiveCollectDeps(target, &all_deps);
+
+ OutputString("Recursive dependencies of " +
+ target->label().GetUserVisibleName(true) + "\n",
+ DECORATION_YELLOW);
+
+ for (std::set<Label>::iterator i = all_deps.begin();
+ i != all_deps.end(); ++i)
+ OutputString(" " + i->GetUserVisibleName(target_toolchain) + "\n");
+ return 0;
+}
+
+int RunTreeCommand(const std::vector<std::string>& args) {
+ if (args.size() != 1) {
+ Err(Location(), "You're holding it wrong.",
+ "Usage: \"gn tree <target_name>\"").PrintToStdout();
+ return NULL;
+ }
+
+ const Target* target = GetTargetForDesc(args);
+ if (!target)
+ return 1;
+
+ OutputString(target->label().GetUserVisibleName(false) + "\n");
+ RecursivePrintDeps(target, target->label().GetToolchainLabel(), 1);
+
+ return 0;
+}
diff --git a/tools/gn/command_gen.cc b/tools/gn/command_gen.cc
new file mode 100644
index 0000000..ab64a8d
--- /dev/null
+++ b/tools/gn/command_gen.cc
@@ -0,0 +1,66 @@
+// 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 "base/bind.h"
+#include "base/command_line.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/time/time.h"
+#include "tools/gn/build_settings.h"
+#include "tools/gn/commands.h"
+#include "tools/gn/ninja_target_writer.h"
+#include "tools/gn/ninja_writer.h"
+#include "tools/gn/scheduler.h"
+#include "tools/gn/setup.h"
+#include "tools/gn/standard_out.h"
+
+namespace {
+
+// Suppress output on success.
+const char kSwitchQuiet[] = "q";
+
+} // namespace
+
+int RunGenCommand(const std::vector<std::string>& args) {
+ base::TimeTicks begin_time = base::TimeTicks::Now();
+
+ // Deliberately leaked to avoid expensive process teardown.
+ Setup* setup = new Setup;
+ if (!setup->DoSetup())
+ return 1;
+
+ // Cause the load to also generate the ninja files for each target.
+ setup->build_settings().set_target_resolved_callback(
+ base::Bind(&NinjaTargetWriter::RunAndWriteFile));
+
+ // Do the actual load. This will also write out the target ninja files.
+ if (!setup->Run())
+ return 1;
+
+ // Write the root ninja files.
+ if (!NinjaWriter::RunAndWriteFiles(&setup->build_settings())) {
+ Err(Location(),
+ "Couldn't open root buildfile(s) for writing").PrintToStdout();
+ return 1;
+ }
+
+ base::TimeTicks end_time = base::TimeTicks::Now();
+
+ if (!CommandLine::ForCurrentProcess()->HasSwitch(kSwitchQuiet)) {
+ OutputString("Done. ", DECORATION_GREEN);
+
+ // TODO(brettw) get the number of targets without getting the entire list.
+ std::vector<const Target*> all_targets;
+ setup->build_settings().target_manager().GetAllTargets(&all_targets);
+ std::string stats = "Generated " +
+ base::IntToString(static_cast<int>(all_targets.size())) +
+ " targets from " +
+ base::IntToString(
+ setup->scheduler().input_file_manager()->GetInputFileCount()) +
+ " files in " +
+ base::IntToString((end_time - begin_time).InMilliseconds()) + "ms\n";
+ OutputString(stats);
+ }
+
+ return 0;
+}
diff --git a/tools/gn/commands.h b/tools/gn/commands.h
new file mode 100644
index 0000000..1d4449c
--- /dev/null
+++ b/tools/gn/commands.h
@@ -0,0 +1,18 @@
+// 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_COMMANDS_H_
+#define TOOLS_GN_COMMANDS_H_
+
+#include <string>
+#include <vector>
+
+// The different commands we have, returns the value we should return from
+// main().
+int RunDepsCommand(const std::vector<std::string>& args);
+int RunDescCommand(const std::vector<std::string>& args);
+int RunGenCommand(const std::vector<std::string>& args);
+int RunTreeCommand(const std::vector<std::string>& args);
+
+#endif // TOOLS_GN_COMMANDS_H_
diff --git a/tools/gn/config.cc b/tools/gn/config.cc
new file mode 100644
index 0000000..1175d7f
--- /dev/null
+++ b/tools/gn/config.cc
@@ -0,0 +1,78 @@
+// 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/config.h"
+
+#include "tools/gn/err.h"
+#include "tools/gn/input_file_manager.h"
+#include "tools/gn/item_node.h"
+#include "tools/gn/item_tree.h"
+#include "tools/gn/scheduler.h"
+
+Config::Config(const Label& label) : Item(label) {
+}
+
+Config::~Config() {
+}
+
+Config* Config::AsConfig() {
+ return this;
+}
+
+const Config* Config::AsConfig() const {
+ return this;
+}
+
+// static
+Config* Config::GetConfig(const Settings* settings,
+ const LocationRange& specified_from_here,
+ const Label& label,
+ Item* dep_from,
+ Err* err) {
+ DCHECK(!label.is_null());
+
+ ItemTree* tree = &settings->build_settings()->item_tree();
+ base::AutoLock lock(tree->lock());
+
+ ItemNode* node = tree->GetExistingNodeLocked(label);
+ Config* config = NULL;
+ if (!node) {
+ config = new Config(label);
+ node = new ItemNode(config);
+ tree->AddNodeLocked(node);
+
+ // Only schedule loading the given target if somebody is depending on it
+ // (and we optimize by not re-asking it to run the current file).
+ // Otherwise, we're probably generating it right now.
+ if (dep_from && dep_from->label().dir() != label.dir()) {
+ settings->build_settings()->toolchain_manager().ScheduleInvocationLocked(
+ specified_from_here, label.GetToolchainLabel(), label.dir(),
+ err);
+ }
+ } else if ((config = node->item()->AsConfig())) {
+ // Previously saw this item as a config.
+
+ // If we have no dep_from, we're generating it. In this case, it had better
+ // not already be generated.
+ if (!dep_from && node->state() != ItemNode::REFERENCED) {
+ *err = Err(specified_from_here, "Duplicate config definition.",
+ "You already told me about a config with this name.");
+ return NULL;
+ }
+ } else {
+ // Previously saw this thing as a non-config.
+ *err = Err(specified_from_here,
+ "Config name already used.",
+ "Previously you specified a " +
+ node->item()->GetItemTypeName() + " with this name instead.");
+ return NULL;
+ }
+
+ // Keep a record of the guy asking us for this dependency. We know if
+ // somebody is adding a dependency, that guy it himself not resolved.
+ if (dep_from && node->state() != ItemNode::RESOLVED)
+ tree->GetExistingNodeLocked(dep_from->label())->AddDependency(node);
+
+ return config;
+}
diff --git a/tools/gn/config.h b/tools/gn/config.h
new file mode 100644
index 0000000..0ee9b7b
--- /dev/null
+++ b/tools/gn/config.h
@@ -0,0 +1,45 @@
+// 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_CONFIG_H_
+#define TOOLS_GN_CONFIG_H_
+
+#include "base/compiler_specific.h"
+#include "tools/gn/config_values.h"
+#include "tools/gn/item.h"
+
+class Err;
+class ItemTree;
+class LocationRange;
+class Settings;
+
+// Represents a named config in the dependency graph.
+class Config : public Item {
+ public:
+ Config(const Label& label);
+ virtual ~Config();
+
+ virtual Config* AsConfig() OVERRIDE;
+ virtual const Config* AsConfig() const OVERRIDE;
+
+ ConfigValues& config_values() { return config_values_; }
+ const ConfigValues& config_values() const { return config_values_; }
+
+ // Gets or creates a config.
+ //
+ // This is like the TargetManager is for Targets, but Configs are so much
+ // simpler that this one function is all we need.
+ static Config* GetConfig(const Settings* settings,
+ const LocationRange& specified_from_here,
+ const Label& label,
+ Item* dep_from,
+ Err* err);
+
+ private:
+ ConfigValues config_values_;
+
+ DISALLOW_COPY_AND_ASSIGN(Config);
+};
+
+#endif // TOOLS_GN_CONFIG_H_
diff --git a/tools/gn/config_values.cc b/tools/gn/config_values.cc
new file mode 100644
index 0000000..53466df
--- /dev/null
+++ b/tools/gn/config_values.cc
@@ -0,0 +1,11 @@
+// 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/config_values.h"
+
+ConfigValues::ConfigValues() {
+}
+
+ConfigValues::~ConfigValues() {
+}
diff --git a/tools/gn/config_values.h b/tools/gn/config_values.h
new file mode 100644
index 0000000..e7c1712
--- /dev/null
+++ b/tools/gn/config_values.h
@@ -0,0 +1,50 @@
+// 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_CONFIG_VALUES_H_
+#define TOOLS_GN_CONFIG_VALUES_H_
+
+#include <string>
+#include <vector>
+
+#include "base/basictypes.h"
+#include "tools/gn/source_dir.h"
+
+// Holds the values (includes, defines, compiler flags, etc.) for a given
+// config or target.
+class ConfigValues {
+ public:
+ ConfigValues();
+ ~ConfigValues();
+
+ const std::vector<SourceDir>& includes() const { return includes_; }
+ void swap_in_includes(std::vector<SourceDir>* lo) { includes_.swap(*lo); }
+
+ const std::vector<std::string>& defines() const { return defines_; }
+ void swap_in_defines(std::vector<std::string>* d) { defines_.swap(*d); }
+
+ const std::vector<std::string>& cflags() const { return cflags_; }
+ void swap_in_cflags(std::vector<std::string>* lo) { cflags_.swap(*lo); }
+
+ const std::vector<std::string>& cflags_c() const { return cflags_c_; }
+ void swap_in_cflags_c(std::vector<std::string>* lo) { cflags_c_.swap(*lo); }
+
+ const std::vector<std::string>& cflags_cc() const { return cflags_cc_; }
+ void swap_in_cflags_cc(std::vector<std::string>* lo) { cflags_cc_.swap(*lo); }
+
+ const std::vector<std::string>& ldflags() const { return ldflags_; }
+ void swap_in_ldflags(std::vector<std::string>* lo) { ldflags_.swap(*lo); }
+
+ private:
+ std::vector<SourceDir> includes_;
+ std::vector<std::string> defines_;
+ std::vector<std::string> cflags_;
+ std::vector<std::string> cflags_c_;
+ std::vector<std::string> cflags_cc_;
+ std::vector<std::string> ldflags_;
+
+ DISALLOW_COPY_AND_ASSIGN(ConfigValues);
+};
+
+#endif // TOOLS_GN_CONFIG_VALUES_H_
diff --git a/tools/gn/config_values_extractors.cc b/tools/gn/config_values_extractors.cc
new file mode 100644
index 0000000..96b514a
--- /dev/null
+++ b/tools/gn/config_values_extractors.cc
@@ -0,0 +1,22 @@
+// 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/config_values_extractors.h"
+
+namespace {
+
+struct StringWriter {
+ void operator()(const std::string& s, std::ostream& out) const {
+ out << " " << s;
+ }
+};
+
+} // namespace
+
+void RecursiveTargetConfigStringsToStream(
+ const Target* target,
+ const std::vector<std::string>& (ConfigValues::* getter)() const,
+ std::ostream& out) {
+ RecursiveTargetConfigToStream(target, getter, StringWriter(), out);
+}
diff --git a/tools/gn/config_values_extractors.h b/tools/gn/config_values_extractors.h
new file mode 100644
index 0000000..0eaa2c9
--- /dev/null
+++ b/tools/gn/config_values_extractors.h
@@ -0,0 +1,50 @@
+// 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_CONFIG_VALUES_EXTRACTORS_H_
+#define TOOLS_GN_CONFIG_VALUES_EXTRACTORS_H_
+
+#include <ostream>
+#include <string>
+#include <vector>
+
+#include "tools/gn/config.h"
+#include "tools/gn/config_values.h"
+#include "tools/gn/target.h"
+
+template<typename T, class Writer>
+inline void ConfigValuesToStream(
+ const ConfigValues& values,
+ const std::vector<T>& (ConfigValues::* getter)() const,
+ const Writer& writer,
+ std::ostream& out) {
+ const std::vector<T>& v = (values.*getter)();
+ for (size_t i = 0; i < v.size(); i++)
+ writer(v[i], out);
+};
+
+template<typename T, class Writer>
+inline void RecursiveTargetConfigToStream(
+ const Target* target,
+ const std::vector<T>& (ConfigValues::* getter)() const,
+ const Writer& writer,
+ std::ostream& out) {
+ // Write all configs in reverse order (to get oldest first, which will look
+ // more normal in the output).
+ for (int i = static_cast<int>(target->configs().size() - 1); i >= 0; i--) {
+ ConfigValuesToStream(target->configs()[i]->config_values(), getter,
+ writer, out);
+ }
+
+ // Last write from the config from the Target itself, if any.
+ ConfigValuesToStream(target->config_values(), getter, writer, out);
+}
+
+// Writes the values out as strings with no transformation.
+void RecursiveTargetConfigStringsToStream(
+ const Target* target,
+ const std::vector<std::string>& (ConfigValues::* getter)() const,
+ std::ostream& out);
+
+#endif // TOOLS_GN_CONFIG_VALUES_EXTRACTORS_H_
diff --git a/tools/gn/config_values_generator.cc b/tools/gn/config_values_generator.cc
new file mode 100644
index 0000000..34c3f67
--- /dev/null
+++ b/tools/gn/config_values_generator.cc
@@ -0,0 +1,89 @@
+// 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/config_values_generator.h"
+
+#include "tools/gn/config_values.h"
+#include "tools/gn/scope.h"
+#include "tools/gn/value.h"
+#include "tools/gn/value_extractors.h"
+
+namespace {
+
+void GetStringList(
+ const Scope* scope,
+ const char* var_name,
+ ConfigValues* config_values,
+ void (ConfigValues::* swapper_inner)(std::vector<std::string>*),
+ Err* err) {
+ const Value* value = scope->GetValue(var_name);
+ if (!value)
+ return; // No value, empty input and succeed.
+
+ std::vector<std::string> result;
+ ExtractListOfStringValues(*value, &result, err);
+ (config_values->*swapper_inner)(&result);
+}
+
+} // namespace
+
+ConfigValuesGenerator::ConfigValuesGenerator(ConfigValues* dest_values,
+ const Scope* scope,
+ const Token& function_token,
+ const SourceDir& input_dir,
+ Err* err)
+ : config_values_(dest_values),
+ scope_(scope),
+ function_token_(function_token),
+ input_dir_(input_dir),
+ err_(err) {
+}
+
+ConfigValuesGenerator::~ConfigValuesGenerator() {
+}
+
+void ConfigValuesGenerator::Run() {
+ FillDefines();
+ FillIncludes();
+ FillCflags();
+ FillCflags_C();
+ FillCflags_CC();
+ FillLdflags();
+}
+
+void ConfigValuesGenerator::FillDefines() {
+ GetStringList(scope_, "defines", config_values_,
+ &ConfigValues::swap_in_defines, err_);
+}
+
+void ConfigValuesGenerator::FillIncludes() {
+ const Value* value = scope_->GetValue("includes");
+ if (!value)
+ return; // No value, empty input and succeed.
+
+ std::vector<SourceDir> includes;
+ if (!ExtractListOfRelativeDirs(*value, input_dir_, &includes, err_))
+ return;
+ config_values_->swap_in_includes(&includes);
+}
+
+void ConfigValuesGenerator::FillCflags() {
+ GetStringList(scope_, "cflags", config_values_,
+ &ConfigValues::swap_in_cflags, err_);
+}
+
+void ConfigValuesGenerator::FillCflags_C() {
+ GetStringList(scope_, "cflags_c", config_values_,
+ &ConfigValues::swap_in_cflags_c, err_);
+}
+
+void ConfigValuesGenerator::FillCflags_CC() {
+ GetStringList(scope_, "cflags_cc", config_values_,
+ &ConfigValues::swap_in_cflags_cc, err_);
+}
+
+void ConfigValuesGenerator::FillLdflags() {
+ GetStringList(scope_, "ldflags", config_values_,
+ &ConfigValues::swap_in_ldflags, err_);
+}
diff --git a/tools/gn/config_values_generator.h b/tools/gn/config_values_generator.h
new file mode 100644
index 0000000..79d9067
--- /dev/null
+++ b/tools/gn/config_values_generator.h
@@ -0,0 +1,48 @@
+// 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_CONFIG_VALUES_GENERATOR_H_
+#define TOOLS_GN_CONFIG_VALUES_GENERATOR_H_
+
+#include <string>
+#include <vector>
+
+#include "base/basictypes.h"
+#include "tools/gn/source_dir.h"
+
+class ConfigValues;
+class Err;
+class Scope;
+class Token;
+
+class ConfigValuesGenerator {
+ public:
+ ConfigValuesGenerator(ConfigValues* dest_values,
+ const Scope* scope,
+ const Token& function_token,
+ const SourceDir& input_dir,
+ Err* err);
+ ~ConfigValuesGenerator();
+
+ // Sets the error passed to the constructor on failure.
+ void Run();
+
+ private:
+ void FillDefines();
+ void FillIncludes();
+ void FillCflags();
+ void FillCflags_C();
+ void FillCflags_CC();
+ void FillLdflags();
+
+ ConfigValues* config_values_;
+ const Scope* scope_;
+ const Token& function_token_;
+ const SourceDir input_dir_;
+ Err* err_;
+
+ DISALLOW_COPY_AND_ASSIGN(ConfigValuesGenerator);
+};
+
+#endif // TOOLS_GN_CONFIG_VALUES_GENERATOR_H_
diff --git a/tools/gn/err.cc b/tools/gn/err.cc
new file mode 100644
index 0000000..068ea6d
--- /dev/null
+++ b/tools/gn/err.cc
@@ -0,0 +1,196 @@
+// 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/err.h"
+
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_util.h"
+#include "tools/gn/filesystem_utils.h"
+#include "tools/gn/input_file.h"
+#include "tools/gn/parse_tree.h"
+#include "tools/gn/standard_out.h"
+#include "tools/gn/tokenizer.h"
+#include "tools/gn/value.h"
+
+namespace {
+
+std::string GetNthLine(const base::StringPiece& data, int n) {
+ size_t line_off = Tokenizer::ByteOffsetOfNthLine(data, n);
+ size_t end = line_off + 1;
+ while (end < data.size() && !Tokenizer::IsNewline(data, end))
+ end++;
+ return data.substr(line_off, end - line_off).as_string();
+}
+
+void FillRangeOnLine(const LocationRange& range, int line_number,
+ std::string* line) {
+ // Only bother if the range's begin or end overlaps the line. If the entire
+ // line is highlighted as a result of this range, it's not very helpful.
+ if (range.begin().line_number() != line_number &&
+ range.end().line_number() != line_number)
+ return;
+
+ // Watch out, the char offsets in the location are 1-based, so we have to
+ // subtract 1.
+ int begin_char;
+ if (range.begin().line_number() < line_number)
+ begin_char = 0;
+ else
+ begin_char = range.begin().char_offset() - 1;
+
+ int end_char;
+ if (range.end().line_number() > line_number)
+ end_char = line->size(); // Ending is non-inclusive.
+ else
+ end_char = range.end().char_offset() - 1;
+
+ CHECK(end_char >= begin_char);
+ CHECK(begin_char >= 0 && begin_char <= static_cast<int>(line->size()));
+ CHECK(end_char >= 0 && end_char <= static_cast<int>(line->size()));
+ for (int i = begin_char; i < end_char; i++)
+ line->at(i) = '-';
+}
+
+// The line length is used to clip the maximum length of the markers we'll
+// make if the error spans more than one line (like unterminated literals).
+void OutputHighlighedPosition(const Location& location,
+ const Err::RangeList& ranges,
+ size_t line_length) {
+ // Make a buffer of the line in spaces.
+ std::string highlight;
+ highlight.resize(line_length);
+ for (size_t i = 0; i < line_length; i++)
+ highlight[i] = ' ';
+
+ // Highlight all the ranges on the line.
+ for (size_t i = 0; i < ranges.size(); i++)
+ FillRangeOnLine(ranges[i], location.line_number(), &highlight);
+
+ // Allow the marker to be one past the end of the line for marking the end.
+ highlight.push_back(' ');
+ CHECK(location.char_offset() - 1 >= 0 &&
+ location.char_offset() - 1 < static_cast<int>(highlight.size()));
+ highlight[location.char_offset() - 1] = '^';
+
+ // Trim unused spaces from end of line.
+ while (!highlight.empty() && highlight[highlight.size() - 1] == ' ')
+ highlight.resize(highlight.size() - 1);
+
+ highlight += "\n";
+ OutputString(highlight, DECORATION_BLUE);
+}
+
+} // namespace
+
+Err::Err() : has_error_(false) {
+}
+
+Err::Err(const Location& location,
+ const std::string& msg,
+ const std::string& help)
+ : has_error_(true),
+ location_(location),
+ message_(msg),
+ help_text_(help) {
+}
+
+Err::Err(const LocationRange& range,
+ const std::string& msg,
+ const std::string& help)
+ : has_error_(true),
+ location_(range.begin()),
+ message_(msg),
+ help_text_(help) {
+ ranges_.push_back(range);
+}
+
+Err::Err(const Token& token,
+ const std::string& msg,
+ const std::string& help)
+ : has_error_(true),
+ location_(token.location()),
+ message_(msg),
+ help_text_(help) {
+ ranges_.push_back(token.range());
+}
+
+Err::Err(const ParseNode* node,
+ const std::string& msg,
+ const std::string& help_text)
+ : has_error_(true),
+ message_(msg),
+ help_text_(help_text) {
+ // Node will be null in certain tests.
+ if (node) {
+ LocationRange range = node->GetRange();
+ location_ = range.begin();
+ ranges_.push_back(range);
+ }
+}
+
+Err::Err(const Value& value,
+ const std::string msg,
+ const std::string& help_text)
+ : has_error_(true),
+ message_(msg),
+ help_text_(help_text) {
+ if (value.origin()) {
+ LocationRange range = value.origin()->GetRange();
+ location_ = range.begin();
+ ranges_.push_back(range);
+ }
+}
+
+Err::~Err() {
+}
+
+void Err::PrintToStdout() const {
+ InternalPrintToStdout(false);
+}
+
+void Err::AppendSubErr(const Err& err) {
+ sub_errs_.push_back(err);
+}
+
+void Err::InternalPrintToStdout(bool is_sub_err) const {
+ DCHECK(has_error_);
+
+ if (!is_sub_err)
+ OutputString("ERROR ", DECORATION_RED);
+
+ // File name and location.
+ const InputFile* input_file = location_.file();
+ std::string loc_str;
+ if (input_file) {
+ std::string path8;
+ path8.assign(input_file->name().value());
+
+ if (is_sub_err)
+ loc_str = "See ";
+ else
+ loc_str = "at ";
+ loc_str += path8 + ": " +
+ base::IntToString(location_.line_number()) + ":" +
+ base::IntToString(location_.char_offset()) + ": ";
+ }
+ OutputString(loc_str + message_ + "\n");
+
+ // Quoted line.
+ if (input_file) {
+ std::string line = GetNthLine(input_file->contents(),
+ location_.line_number());
+ if (!ContainsOnlyWhitespaceASCII(line)) {
+ OutputString(line + "\n", DECORATION_BOLD);
+ OutputHighlighedPosition(location_, ranges_, line.size());
+ }
+ }
+
+ // Optional help text.
+ if (!help_text_.empty())
+ OutputString(help_text_ + "\n");
+
+ // Sub errors.
+ for (size_t i = 0; i < sub_errs_.size(); i++)
+ sub_errs_[i].InternalPrintToStdout(true);
+}
diff --git a/tools/gn/err.h b/tools/gn/err.h
new file mode 100644
index 0000000..3e077e9
--- /dev/null
+++ b/tools/gn/err.h
@@ -0,0 +1,85 @@
+// 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_ERR_H_
+#define TOOLS_GN_ERR_H_
+
+#include <string>
+#include <vector>
+
+#include "tools/gn/location.h"
+#include "tools/gn/token.h"
+
+class ParseNode;
+class Value;
+
+// Result of doing some operation. Check has_error() to see if an error
+// occurred.
+//
+// An error has a location and a message. Below that, is some optional help
+// text to go with the annotation of the location.
+//
+// An error can also have sub-errors which are additionally printed out
+// below. They can provide additional context.
+class Err {
+ public:
+ typedef std::vector<LocationRange> RangeList;
+
+ // Indicates no error.
+ Err();
+
+ // Error at a single point.
+ Err(const Location& location,
+ const std::string& msg,
+ const std::string& help = std::string());
+
+ // Error at a given range.
+ Err(const LocationRange& range,
+ const std::string& msg,
+ const std::string& help = std::string());
+
+ // Error at a given token.
+ Err(const Token& token,
+ const std::string& msg,
+ const std::string& help_text = std::string());
+
+ // Error at a given node.
+ Err(const ParseNode* node,
+ const std::string& msg,
+ const std::string& help_text = std::string());
+
+ // Error at a given value.
+ Err(const Value& value,
+ const std::string msg,
+ const std::string& help_text = std::string());
+
+ ~Err();
+
+ bool has_error() const { return has_error_; }
+ const Location& location() const { return location_; }
+ const std::string& message() const { return message_; }
+ const std::string& help_text() const { return help_text_; }
+
+ void AppendRange(const LocationRange& range) { ranges_.push_back(range); }
+ const RangeList& ranges() const { return ranges_; }
+
+ void AppendSubErr(const Err& err);
+
+ void PrintToStdout() const;
+
+ private:
+ void InternalPrintToStdout(bool is_sub_err) const;
+
+ bool has_error_;
+ Location location_;
+
+ std::vector<LocationRange> ranges_;
+
+ std::string message_;
+ std::string help_text_;
+
+ std::vector<Err> sub_errs_;
+};
+
+#endif // TOOLS_GN_ERR_H_
diff --git a/tools/gn/escape.cc b/tools/gn/escape.cc
new file mode 100644
index 0000000..5fc7b6f
--- /dev/null
+++ b/tools/gn/escape.cc
@@ -0,0 +1,77 @@
+// 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/escape.h"
+
+#include "base/containers/stack_container.h"
+
+namespace {
+
+template<typename DestString>
+void EscapeStringToString(const base::StringPiece& str,
+ const EscapeOptions& options,
+ DestString* dest) {
+ bool used_quotes = false;
+
+ for (size_t i = 0; i < str.size(); i++) {
+ if (str[i] == '$' && options.mode == ESCAPE_NINJA) {
+ // Escape dollars signs since ninja treats these specially.
+ dest->push_back('$');
+ dest->push_back('$');
+ } else if (str[i] == '"' && options.mode == ESCAPE_SHELL) {
+ // Escape quotes with backslashes for the command-line (Ninja doesn't
+ // care).
+ dest->push_back('\\');
+ dest->push_back('"');
+ } else if (str[i] == ' ') {
+ if (options.mode == ESCAPE_NINJA) {
+ // For ninja just escape spaces with $.
+ dest->push_back('$');
+ } else if (options.mode == ESCAPE_SHELL && !options.inhibit_quoting) {
+ // For the shell, quote the whole string.
+ if (!used_quotes) {
+ used_quotes = true;
+ dest->insert(dest->begin(), '"');
+ }
+ }
+ dest->push_back(' ');
+#if defined(OS_WIN)
+ } else if (str[i] == '/' && options.convert_slashes) {
+ // Convert slashes on Windows if requested.
+ dest->push_back('\\');
+#else
+ } else if (str[i] == '\\' && options.mode == ESCAPE_SHELL) {
+ // For non-Windows shell, escape backslashes.
+ dest->push_back('\\');
+ dest->push_back('\\');
+#endif
+ } else {
+ dest->push_back(str[i]);
+ }
+ }
+
+ if (used_quotes)
+ dest->push_back('"');
+}
+
+} // namespace
+
+std::string EscapeString(const base::StringPiece& str,
+ const EscapeOptions& options) {
+ std::string result;
+ result.reserve(str.size() + 4); // Guess we'll add a couple of extra chars.
+ EscapeStringToString(str, options, &result);
+ return result;
+}
+
+void EscapeStringToStream(std::ostream& out,
+ const base::StringPiece& str,
+ const EscapeOptions& options) {
+ // Escape to a stack buffer and then write out to the stream.
+ base::StackVector<char, 256> result;
+ result->reserve(str.size() + 4); // Guess we'll add a couple of extra chars.
+ EscapeStringToString(str, options, &result.container());
+ if (!result->empty())
+ out.write(result->data(), result->size());
+}
diff --git a/tools/gn/escape.h b/tools/gn/escape.h
new file mode 100644
index 0000000..1791161
--- /dev/null
+++ b/tools/gn/escape.h
@@ -0,0 +1,53 @@
+// 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_ESCAPE_H_
+#define TOOLS_GN_ESCAPE_H_
+
+#include <iosfwd>
+
+#include "base/strings/string_piece.h"
+
+// TODO(brettw) we may need to make this a bitfield. If we want to write a
+// shell command in a ninja file, we need the shell characters to be escaped,
+// and THEN the ninja characters. Or maybe we require the caller to do two
+// passes.
+enum EscapingMode {
+ ESCAPE_NONE, // No escaping.
+ ESCAPE_NINJA, // Ninja string escaping.
+ ESCAPE_SHELL, // Shell string escaping.
+};
+
+struct EscapeOptions {
+ EscapeOptions()
+ : mode(ESCAPE_NONE),
+ convert_slashes(false),
+ inhibit_quoting(false) {
+ }
+
+ EscapingMode mode;
+
+ // When set, converts forward-slashes to system-specific path separators.
+ bool convert_slashes;
+
+ // When the escaping mode is ESCAPE_SHELL, the escaper will normally put
+ // quotes around things with spaces. If this value is set to true, we'll
+ // disable the quoting feature and just add the spaces.
+ //
+ // This mode is for when quoting is done at some higher-level. Defaults to
+ // false.
+ bool inhibit_quoting;
+};
+
+// Escapes the given input, returnining the result.
+std::string EscapeString(const base::StringPiece& str,
+ const EscapeOptions& options);
+
+// Same as EscapeString but writes the results to the given stream, saving a
+// copy.
+void EscapeStringToStream(std::ostream& out,
+ const base::StringPiece& str,
+ const EscapeOptions& options);
+
+#endif // TOOLS_GN_ESCAPE_H_
diff --git a/tools/gn/escape_unittest.cc b/tools/gn/escape_unittest.cc
new file mode 100644
index 0000000..a7c19b3
--- /dev/null
+++ b/tools/gn/escape_unittest.cc
@@ -0,0 +1,4 @@
+// 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.
+
diff --git a/tools/gn/file_template.cc b/tools/gn/file_template.cc
new file mode 100644
index 0000000..8b5d09f
--- /dev/null
+++ b/tools/gn/file_template.cc
@@ -0,0 +1,125 @@
+// 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/file_template.h"
+
+#include "tools/gn/filesystem_utils.h"
+
+const char FileTemplate::kSource[] = "{{source}}";
+const char FileTemplate::kSourceNamePart[] = "{{source_name_part}}";
+
+FileTemplate::FileTemplate(const Value& t, Err* err) {
+ ParseInput(t, err);
+}
+
+FileTemplate::FileTemplate(const std::vector<std::string>& t) {
+ for (size_t i = 0; i < t.size(); i++)
+ ParseOneTemplateString(t[i]);
+}
+
+FileTemplate::~FileTemplate() {
+}
+
+void FileTemplate::Apply(const Value& sources,
+ const ParseNode* origin,
+ std::vector<Value>* dest,
+ Err* err) const {
+ if (!sources.VerifyTypeIs(Value::LIST, err))
+ return;
+ dest->reserve(sources.list_value().size() * templates_.container().size());
+
+ // Temporary holding place, allocate outside to re-use- buffer.
+ std::vector<std::string> string_output;
+
+ const std::vector<Value>& sources_list = sources.list_value();
+ for (size_t i = 0; i < sources_list.size(); i++) {
+ if (!sources_list[i].VerifyTypeIs(Value::STRING, err))
+ return;
+
+ ApplyString(sources_list[i].string_value(), &string_output);
+ for (size_t out_i = 0; out_i < string_output.size(); out_i++)
+ dest->push_back(Value(origin, string_output[i]));
+ }
+}
+
+void FileTemplate::ApplyString(const std::string& str,
+ std::vector<std::string>* output) const {
+ // Compute all substitutions needed so we can just do substitutions below.
+ // We skip the LITERAL one since that varies each time.
+ std::string subst[Subrange::NUM_TYPES];
+ if (types_required_[Subrange::SOURCE])
+ subst[Subrange::SOURCE] = str;
+ if (types_required_[Subrange::NAME_PART])
+ subst[Subrange::NAME_PART] = FindFilenameNoExtension(&str).as_string();
+
+ output->resize(templates_.container().size());
+ for (size_t template_i = 0;
+ template_i < templates_.container().size(); template_i++) {
+ const Template& t = templates_[template_i];
+ (*output)[template_i].clear();
+ for (size_t subrange_i = 0; subrange_i < t.container().size();
+ subrange_i++) {
+ if (t[subrange_i].type == Subrange::LITERAL)
+ (*output)[template_i].append(t[subrange_i].literal);
+ else
+ (*output)[template_i].append(subst[t[subrange_i].type]);
+ }
+ }
+}
+
+void FileTemplate::ParseInput(const Value& value, Err* err) {
+ switch (value.type()) {
+ case Value::STRING:
+ ParseOneTemplateString(value.string_value());
+ break;
+ case Value::LIST:
+ for (size_t i = 0; i < value.list_value().size(); i++) {
+ if (!value.list_value()[i].VerifyTypeIs(Value::STRING, err))
+ return;
+ ParseOneTemplateString(value.list_value()[i].string_value());
+ }
+ break;
+ default:
+ *err = Err(value, "File template must be a string or list.",
+ "A sarcastic comment about your skills goes here.");
+ }
+}
+
+void FileTemplate::ParseOneTemplateString(const std::string& str) {
+ templates_.container().resize(templates_.container().size() + 1);
+ Template& t = templates_[templates_.container().size() - 1];
+
+ size_t cur = 0;
+ while (true) {
+ size_t next = str.find("{{", cur);
+
+ // Pick up everything from the previous spot to here as a literal.
+ if (next == std::string::npos) {
+ if (cur != str.size())
+ t.container().push_back(Subrange(Subrange::LITERAL, str.substr(cur)));
+ break;
+ } else if (next > cur) {
+ t.container().push_back(
+ Subrange(Subrange::LITERAL, str.substr(cur, next - cur)));
+ }
+
+ // Decode the template param.
+ if (str.compare(next, arraysize(kSource) - 1, kSource) == 0) {
+ t.container().push_back(Subrange(Subrange::SOURCE));
+ types_required_[Subrange::SOURCE] = true;
+ cur = next + arraysize(kSource) - 1;
+ } else if (str.compare(next, arraysize(kSourceNamePart) - 1,
+ kSourceNamePart) == 0) {
+ t.container().push_back(Subrange(Subrange::NAME_PART));
+ types_required_[Subrange::NAME_PART] = true;
+ cur = next + arraysize(kSourceNamePart) - 1;
+ } else {
+ // If it's not a match, treat it like a one-char literal (this will be
+ // rare, so it's not worth the bother to add to the previous literal) so
+ // we can keep going.
+ t.container().push_back(Subrange(Subrange::LITERAL, "{"));
+ cur = next + 1;
+ }
+ }
+}
diff --git a/tools/gn/file_template.h b/tools/gn/file_template.h
new file mode 100644
index 0000000..25d2251
--- /dev/null
+++ b/tools/gn/file_template.h
@@ -0,0 +1,74 @@
+// 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_FILE_TEMPLATE_H_
+#define TOOLS_GN_FILE_TEMPLATE_H_
+
+#include "base/basictypes.h"
+#include "base/containers/stack_container.h"
+#include "tools/gn/err.h"
+#include "tools/gn/value.h"
+
+class ParseNode;
+
+class FileTemplate {
+ public:
+ struct Subrange {
+ enum Type {
+ LITERAL = 0,
+ SOURCE,
+ NAME_PART,
+ NUM_TYPES // Must be last
+ };
+ Subrange(Type t, const std::string& l = std::string())
+ : type(t),
+ literal(l) {
+ }
+
+ Type type;
+
+ // When type_ == LITERAL, this specifies the literal.
+ std::string literal;
+ };
+
+ // Constructs a template from the given value. On error, the err will be
+ // set. In this case you should not use this object.
+ FileTemplate(const Value& t, Err* err);
+ FileTemplate(const std::vector<std::string>& t);
+ ~FileTemplate();
+
+ // Applies this template to the given list of sources, appending all
+ // results to the given dest list. The sources must be a list for the
+ // one that takes a value as an input, otherwise the given error will be set.
+ void Apply(const Value& sources,
+ const ParseNode* origin,
+ std::vector<Value>* dest,
+ Err* err) const;
+ void ApplyString(const std::string& input,
+ std::vector<std::string>* output) const;
+
+ // Known template types.
+ static const char kSource[];
+ static const char kSourceNamePart[];
+
+ private:
+ typedef base::StackVector<Subrange, 8> Template;
+ typedef base::StackVector<Template, 8> TemplateVector;
+
+ void ParseInput(const Value& value, Err* err);
+
+ // Parses a template string and adds it to the templates_ list.
+ void ParseOneTemplateString(const std::string& str);
+
+ TemplateVector templates_;
+
+ // The corresponding value is set to true if the given subrange type is
+ // required. This allows us to precompute these types whem applying them
+ // to a given source file.
+ bool types_required_[Subrange::NUM_TYPES];
+
+ DISALLOW_COPY_AND_ASSIGN(FileTemplate);
+};
+
+#endif // TOOLS_GN_FILE_TEMPLATE_H_
diff --git a/tools/gn/file_template_unittest.cc b/tools/gn/file_template_unittest.cc
new file mode 100644
index 0000000..47c84f0
--- /dev/null
+++ b/tools/gn/file_template_unittest.cc
@@ -0,0 +1,45 @@
+// 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/file_template.h"
+
+TEST(FileTemplate, Static) {
+ std::vector<std::string> templates;
+ templates.push_back("something_static");
+ FileTemplate t(templates);
+
+ std::vector<std::string> result;
+ t.ApplyString("", &result);
+ ASSERT_EQ(1u, result.size());
+ EXPECT_EQ("something_static", result[0]);
+
+ t.ApplyString("lalala", &result);
+ ASSERT_EQ(1u, result.size());
+ EXPECT_EQ("something_static", result[0]);
+}
+
+TEST(FileTemplate, Typical) {
+ std::vector<std::string> templates;
+ templates.push_back("foo/{{source_name_part}}.cc");
+ templates.push_back("foo/{{source_name_part}}.h");
+ FileTemplate t(templates);
+
+ std::vector<std::string> result;
+ t.ApplyString("sources/ha.idl", &result);
+ ASSERT_EQ(2u, result.size());
+ EXPECT_EQ("foo/ha.cc", result[0]);
+ EXPECT_EQ("foo/ha.h", result[1]);
+}
+
+TEST(FileTemplate, Weird) {
+ std::vector<std::string> templates;
+ templates.push_back("{{{source}}{{source}}{{");
+ FileTemplate t(templates);
+
+ std::vector<std::string> result;
+ t.ApplyString("foo/lalala.c", &result);
+ ASSERT_EQ(1u, result.size());
+ EXPECT_EQ("{foo/lalala.cfoo/lalala.c{{", result[0]);
+}
diff --git a/tools/gn/filesystem_utils.cc b/tools/gn/filesystem_utils.cc
new file mode 100644
index 0000000..625a358
--- /dev/null
+++ b/tools/gn/filesystem_utils.cc
@@ -0,0 +1,350 @@
+// 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/filesystem_utils.h"
+
+#include "base/logging.h"
+#include "base/strings/utf_string_conversions.h"
+#include "build/build_config.h"
+#include "tools/gn/location.h"
+#include "tools/gn/source_dir.h"
+
+namespace {
+
+enum DotDisposition {
+ // The given dot is just part of a filename and is not special.
+ NOT_A_DIRECTORY,
+
+ // The given dot is the current directory.
+ DIRECTORY_CUR,
+
+ // The given dot is the first of a double dot that should take us up one.
+ DIRECTORY_UP
+};
+
+// When we find a dot, this function is called with the character following
+// that dot to see what it is. The return value indicates what type this dot is
+// (see above). This code handles the case where the dot is at the end of the
+// input.
+//
+// |*consumed_len| will contain the number of characters in the input that
+// express what we found.
+DotDisposition ClassifyAfterDot(const std::string& path,
+ size_t after_dot,
+ size_t* consumed_len) {
+ if (after_dot == path.size()) {
+ // Single dot at the end.
+ *consumed_len = 1;
+ return DIRECTORY_CUR;
+ }
+ if (path[after_dot] == '/') {
+ // Single dot followed by a slash.
+ *consumed_len = 2; // Consume the slash
+ return DIRECTORY_CUR;
+ }
+
+ if (path[after_dot] == '.') {
+ // Two dots.
+ if (after_dot + 1 == path.size()) {
+ // Double dot at the end.
+ *consumed_len = 2;
+ return DIRECTORY_UP;
+ }
+ if (path[after_dot + 1] == '/') {
+ // Double dot folowed by a slash.
+ *consumed_len = 3;
+ return DIRECTORY_UP;
+ }
+ }
+
+ // The dots are followed by something else, not a directory.
+ *consumed_len = 1;
+ return NOT_A_DIRECTORY;
+}
+
+} // namesapce
+
+SourceFileType GetSourceFileType(const SourceFile& file,
+ Settings::TargetOS os) {
+ 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;
+
+ switch (os) {
+ case Settings::MAC:
+ if (extension == "m")
+ return SOURCE_M;
+ if (extension == "mm")
+ return SOURCE_MM;
+ break;
+
+ case Settings::WIN:
+ if (extension == "rc")
+ return SOURCE_RC;
+ break;
+
+ default:
+ break;
+ }
+
+ // TODO(brettw) asm files.
+ // TODO(brettw) weird thing with .S on non-Windows platforms.
+ return SOURCE_UNKNOWN;
+}
+
+const char* GetExtensionForOutputType(Target::OutputType type,
+ Settings::TargetOS os) {
+ switch (os) {
+ case Settings::WIN:
+ switch (type) {
+ case Target::NONE:
+ NOTREACHED();
+ return "";
+ case Target::EXECUTABLE:
+ return "exe";
+ case Target::SHARED_LIBRARY:
+ return "dll.lib"; // Extension of import library.
+ case Target::STATIC_LIBRARY:
+ return "lib";
+ case Target::LOADABLE_MODULE:
+ return "dll"; // TODO(brettw) what's this?
+ default:
+ NOTREACHED();
+ }
+ break;
+
+ default:
+ NOTREACHED();
+ }
+ return "";
+}
+
+std::string FilePathToUTF8(const base::FilePath& path) {
+#if defined(OS_WIN)
+ return WideToUTF8(path.value());
+#else
+ return path.value();
+#endif
+}
+
+base::FilePath UTF8ToFilePath(const base::StringPiece& sp) {
+#if defined(OS_WIN)
+ return base::FilePath(UTF8ToWide(sp));
+#else
+ return base::FilePath(sp.as_string());
+#endif
+}
+
+size_t FindExtensionOffset(const std::string& path) {
+ for (int i = static_cast<int>(path.size()); i >= 0; i--) {
+ if (path[i] == '/')
+ break;
+ if (path[i] == '.')
+ return i + 1;
+ }
+ return std::string::npos;
+}
+
+base::StringPiece FindExtension(const std::string* path) {
+ size_t extension_offset = FindExtensionOffset(*path);
+ if (extension_offset == std::string::npos)
+ return base::StringPiece();
+ return base::StringPiece(&path->data()[extension_offset],
+ path->size() - extension_offset);
+}
+
+size_t FindFilenameOffset(const std::string& path) {
+ for (int i = static_cast<int>(path.size()) - 1; i >= 0; i--) {
+ if (path[i] == '/')
+ return i + 1;
+ }
+ return 0; // No filename found means everything was the filename.
+}
+
+base::StringPiece FindFilename(const std::string* path) {
+ size_t filename_offset = FindFilenameOffset(*path);
+ if (filename_offset == 0)
+ return base::StringPiece(*path); // Everything is the file name.
+ return base::StringPiece(&(*path).data()[filename_offset],
+ path->size() - filename_offset);
+}
+
+base::StringPiece FindFilenameNoExtension(const std::string* path) {
+ if (path->empty())
+ return base::StringPiece();
+ size_t filename_offset = FindFilenameOffset(*path);
+ size_t extension_offset = FindExtensionOffset(*path);
+
+ size_t name_len;
+ if (extension_offset == std::string::npos)
+ name_len = path->size() - filename_offset;
+ else
+ name_len = extension_offset - filename_offset - 1;
+
+ return base::StringPiece(&(*path).data()[filename_offset], name_len);
+}
+
+void RemoveFilename(std::string* path) {
+ path->resize(FindFilenameOffset(*path));
+}
+
+bool EndsWithSlash(const std::string& s) {
+ return !s.empty() && s[s.size() - 1] == '/';
+}
+
+base::StringPiece FindDir(const std::string* path) {
+ size_t filename_offset = FindFilenameOffset(*path);
+ if (filename_offset == 0u)
+ return base::StringPiece();
+ return base::StringPiece(path->data(), filename_offset);
+}
+
+bool EnsureStringIsInOutputDir(const SourceDir& dir,
+ const std::string& str,
+ const Value& originating,
+ Err* err) {
+ // The last char of the dir will be a slash. We don't care if the input ends
+ // in a slash or not, so just compare up until there.
+ //
+ // This check will be wrong for all proper prefixes "e.g. "/output" will
+ // match "/out" but we don't really care since this is just a sanity check.
+ const std::string& dir_str = dir.value();
+ if (str.compare(0, dir_str.length() - 1, dir_str, 0, dir_str.length() - 1)
+ != 0) {
+ *err = Err(originating, "File not inside output directory.",
+ "The given file should be in the output directory. Normally you would "
+ "specify\n\"$target_output_dir/foo\" or "
+ "\"$target_gen_dir/foo\". I interpreted this as\n\""
+ + str + "\".");
+ return false;
+ }
+ return true;
+}
+
+std::string InvertDir(const SourceDir& path) {
+ const std::string value = path.value();
+ if (value.empty())
+ return std::string();
+
+ DCHECK(value[0] == '/');
+ size_t begin_index = 1;
+
+ // If the input begins with two slashes, skip over both (this is a
+ // source-relative dir).
+ if (value.size() > 1 && value[1] == '/')
+ begin_index = 2;
+
+ std::string ret;
+ for (size_t i = begin_index; i < value.size(); i++) {
+ if (value[i] == '/')
+ ret.append("../");
+ }
+ return ret;
+}
+
+void NormalizePath(std::string* path) {
+ char* pathbuf = path->empty() ? NULL : &(*path)[0];
+
+ // top_index is the first character we can modify in the path. Anything
+ // before this indicates where the path is relative to.
+ size_t top_index = 0;
+ bool is_relative = true;
+ if (!path->empty() && pathbuf[0] == '/') {
+ is_relative = false;
+
+ if (path->size() > 1 && pathbuf[1] == '/') {
+ // Two leading slashes, this is a path into the source dir.
+ top_index = 2;
+ } else {
+ // One leading slash, this is a system-absolute path.
+ top_index = 1;
+ }
+ }
+
+ size_t dest_i = top_index;
+ for (size_t src_i = top_index; src_i < path->size(); /* nothing */) {
+ if (pathbuf[src_i] == '.') {
+ if (src_i == 0 || pathbuf[src_i - 1] == '/') {
+ // Slash followed by a dot, see if it's something special.
+ size_t consumed_len;
+ switch (ClassifyAfterDot(*path, src_i + 1, &consumed_len)) {
+ case NOT_A_DIRECTORY:
+ // Copy the dot to the output, it means nothing special.
+ pathbuf[dest_i++] = pathbuf[src_i++];
+ break;
+ case DIRECTORY_CUR:
+ // Current directory, just skip the input.
+ src_i += consumed_len;
+ break;
+ case DIRECTORY_UP:
+ // Back up over previous directory component. If we're already
+ // at the top, preserve the "..".
+ if (dest_i > top_index) {
+ // The previous char was a slash, remove it.
+ dest_i--;
+ }
+
+ if (dest_i == top_index) {
+ if (is_relative) {
+ // We're already at the beginning of a relative input, copy the
+ // ".." and continue. We need the trailing slash if there was
+ // one before (otherwise we're at the end of the input).
+ pathbuf[dest_i++] = '.';
+ pathbuf[dest_i++] = '.';
+ if (consumed_len == 3)
+ pathbuf[dest_i++] = '/';
+
+ // This also makes a new "root" that we can't delete by going
+ // up more levels. Otherwise "../.." would collapse to
+ // nothing.
+ top_index = dest_i;
+ }
+ // Otherwise we're at the beginning of an absolute path. Don't
+ // allow ".." to go up another level and just eat it.
+ } else {
+ // Just find the previous slash or the beginning of input.
+ while (dest_i > 0 && pathbuf[dest_i - 1] != '/')
+ dest_i--;
+ }
+ src_i += consumed_len;
+ }
+ } else {
+ // Dot not preceeded by a slash, copy it literally.
+ pathbuf[dest_i++] = pathbuf[src_i++];
+ }
+ } else if (pathbuf[src_i] == '/') {
+ if (src_i > 0 && pathbuf[src_i - 1] == '/') {
+ // Two slashes in a row, skip over it.
+ src_i++;
+ } else {
+ // Just one slash, copy it.
+ pathbuf[dest_i++] = pathbuf[src_i++];
+ }
+ } else {
+ // Input nothing special, just copy it.
+ pathbuf[dest_i++] = pathbuf[src_i++];
+ }
+ }
+ path->resize(dest_i);
+}
+
+void ConvertPathToSystem(std::string* path) {
+#if defined(OS_WIN)
+ for (size_t i = 0; i < path->size(); i++) {
+ if ((*path)[i] == '/')
+ (*path)[i] = '\\';
+ }
+#endif
+}
+
+std::string PathToSystem(const std::string& path) {
+ std::string ret(path);
+ ConvertPathToSystem(&ret);
+ return ret;
+}
+
diff --git a/tools/gn/filesystem_utils.h b/tools/gn/filesystem_utils.h
new file mode 100644
index 0000000..19139f8
--- /dev/null
+++ b/tools/gn/filesystem_utils.h
@@ -0,0 +1,115 @@
+// 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_FILESYSTEM_UTILS_H_
+#define TOOLS_GN_FILESYSTEM_UTILS_H_
+
+#include <string>
+
+#include "base/files/file_path.h"
+#include "base/strings/string_piece.h"
+#include "tools/gn/settings.h"
+#include "tools/gn/target.h"
+
+class Err;
+class Location;
+class Value;
+
+enum SourceFileType {
+ SOURCE_UNKNOWN,
+ SOURCE_ASM,
+ SOURCE_C,
+ SOURCE_CC,
+ SOURCE_H,
+ SOURCE_M,
+ SOURCE_MM,
+ //SOURCE_S, // TODO(brettw) what is this?
+ SOURCE_RC,
+};
+
+SourceFileType GetSourceFileType(const SourceFile& file,
+ Settings::TargetOS os);
+
+// Returns the extension, not including the dot, for the given file type on the
+// given system.
+//
+// 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).
+const char* GetExtensionForOutputType(Target::OutputType type,
+ Settings::TargetOS os);
+
+std::string FilePathToUTF8(const base::FilePath& path);
+base::FilePath UTF8ToFilePath(const base::StringPiece& sp);
+
+// Extensions -----------------------------------------------------------------
+
+// Returns the index of the extension (character after the last dot not after a
+// slash). Returns std::string::npos if not found. Returns path.size() if the
+// file ends with a dot.
+size_t FindExtensionOffset(const std::string& path);
+
+// Returns a string piece pointing into the input string identifying the
+// extension. Note that the input pointer must outlive the output.
+base::StringPiece FindExtension(const std::string* path);
+
+// Filename parts -------------------------------------------------------------
+
+// Returns the offset of the character following the last slash, or
+// 0 if no slash was found. Returns path.size() if the path ends with a slash.
+// Note that the input pointer must outlive the output.
+size_t FindFilenameOffset(const std::string& path);
+
+// Returns a string piece pointing into the input string identifying the
+// file name (following the last slash, including the extension). Note that the
+// input pointer must outlive the output.
+base::StringPiece FindFilename(const std::string* path);
+
+// Like FindFilename but does not include the extension.
+base::StringPiece FindFilenameNoExtension(const std::string* path);
+
+// Removes everything after the last slash. The last slash, if any, will be
+// preserved.
+void RemoveFilename(std::string* path);
+
+// Returns true if the given path ends with a slash.
+bool EndsWithSlash(const std::string& s);
+
+// Path parts -----------------------------------------------------------------
+
+// Returns a string piece pointing into the input string identifying the
+// directory name of the given path, including the last slash. Note that the
+// input pointer must outlive the output.
+base::StringPiece FindDir(const std::string* path);
+
+// Verifies that the given string references a file inside of the given
+// directory. This is pretty stupid and doesn't handle "." and "..", etc.,
+// it is designed for a sanity check to keep people from writing output files
+// to the source directory accidentally.
+//
+// The originating value will be blamed in the error.
+//
+// If the file isn't in the dir, returns false and sets the error. Otherwise
+// returns true and leaves the error untouched.
+bool EnsureStringIsInOutputDir(const SourceDir& dir,
+ const std::string& str,
+ const Value& originating,
+ Err* err);
+
+// ----------------------------------------------------------------------------
+
+// Converts a directory to its inverse (e.g. "/foo/bar/" -> "../../").
+// This will be the empty string for the root directories ("/" and "//"), and
+// in all other cases, this is guaranteed to end in a slash.
+std::string InvertDir(const SourceDir& dir);
+
+// Collapses "." and sequential "/"s and evaluates "..".
+void NormalizePath(std::string* path);
+
+// Converts slashes to backslashes for Windows. Keeps the string unchanged
+// for other systems.
+void ConvertPathToSystem(std::string* path);
+std::string PathToSystem(const std::string& path);
+
+#endif // TOOLS_GN_FILESYSTEM_UTILS_H_
diff --git a/tools/gn/filesystem_utils_unittest.cc b/tools/gn/filesystem_utils_unittest.cc
new file mode 100644
index 0000000..75bf7cd
--- /dev/null
+++ b/tools/gn/filesystem_utils_unittest.cc
@@ -0,0 +1,146 @@
+// 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 "base/strings/string_util.h"
+#include "base/strings/utf_string_conversions.h"
+#include "build/build_config.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "tools/gn/filesystem_utils.h"
+
+TEST(FilesystemUtils, FileExtensionOffset) {
+ EXPECT_EQ(std::string::npos, FindExtensionOffset(""));
+ EXPECT_EQ(std::string::npos, FindExtensionOffset("foo/bar/baz"));
+ EXPECT_EQ(4u, FindExtensionOffset("foo."));
+ EXPECT_EQ(4u, FindExtensionOffset("f.o.bar"));
+ EXPECT_EQ(std::string::npos, FindExtensionOffset("foo.bar/"));
+ EXPECT_EQ(std::string::npos, FindExtensionOffset("foo.bar/baz"));
+}
+
+TEST(FilesystemUtils, FindExtension) {
+ std::string input;
+ EXPECT_EQ("", FindExtension(&input).as_string());
+ input = "foo/bar/baz";
+ EXPECT_EQ("", FindExtension(&input).as_string());
+ input = "foo.";
+ EXPECT_EQ("", FindExtension(&input).as_string());
+ input = "f.o.bar";
+ EXPECT_EQ("bar", FindExtension(&input).as_string());
+ input = "foo.bar/";
+ EXPECT_EQ("", FindExtension(&input).as_string());
+ input = "foo.bar/baz";
+ EXPECT_EQ("", FindExtension(&input).as_string());
+}
+
+TEST(FilesystemUtils, FindFilenameOffset) {
+ EXPECT_EQ(0u, FindFilenameOffset(""));
+ EXPECT_EQ(0u, FindFilenameOffset("foo"));
+ EXPECT_EQ(4u, FindFilenameOffset("foo/"));
+ EXPECT_EQ(4u, FindFilenameOffset("foo/bar"));
+}
+
+TEST(FilesystemUtils, RemoveFilename) {
+ std::string s;
+
+ RemoveFilename(&s);
+ EXPECT_STREQ("", s.c_str());
+
+ s = "foo";
+ RemoveFilename(&s);
+ EXPECT_STREQ("", s.c_str());
+
+ s = "/";
+ RemoveFilename(&s);
+ EXPECT_STREQ("/", s.c_str());
+
+ s = "foo/bar";
+ RemoveFilename(&s);
+ EXPECT_STREQ("foo/", s.c_str());
+
+ s = "foo/bar/baz.cc";
+ RemoveFilename(&s);
+ EXPECT_STREQ("foo/bar/", s.c_str());
+}
+
+TEST(FilesystemUtils, FindDir) {
+ std::string input;
+ EXPECT_EQ("", FindDir(&input));
+ input = "/";
+ EXPECT_EQ("/", FindDir(&input));
+ input = "foo/";
+ EXPECT_EQ("foo/", FindDir(&input));
+ input = "foo/bar/baz";
+ EXPECT_EQ("foo/bar/", FindDir(&input));
+}
+
+TEST(FilesystemUtils, InvertDir) {
+ EXPECT_TRUE(InvertDir(SourceDir()) == "");
+ EXPECT_TRUE(InvertDir(SourceDir("/")) == "");
+ EXPECT_TRUE(InvertDir(SourceDir("//")) == "");
+
+ EXPECT_TRUE(InvertDir(SourceDir("//foo/bar")) == "../../");
+ EXPECT_TRUE(InvertDir(SourceDir("/foo/bar/")) == "../../");
+}
+
+TEST(FilesystemUtils, NormalizePath) {
+ std::string input;
+
+ NormalizePath(&input);
+ EXPECT_EQ("", input);
+
+ input = "foo/bar.txt";
+ NormalizePath(&input);
+ EXPECT_EQ("foo/bar.txt", input);
+
+ input = ".";
+ NormalizePath(&input);
+ EXPECT_EQ("", input);
+
+ input = "..";
+ NormalizePath(&input);
+ EXPECT_EQ("..", input);
+
+ input = "foo//bar";
+ NormalizePath(&input);
+ EXPECT_EQ("foo/bar", input);
+
+ input = "//foo";
+ NormalizePath(&input);
+ EXPECT_EQ("//foo", input);
+
+ input = "foo/..//bar";
+ NormalizePath(&input);
+ EXPECT_EQ("bar", input);
+
+ input = "foo/../../bar";
+ NormalizePath(&input);
+ EXPECT_EQ("../bar", input);
+
+ input = "/../foo"; // Don't go aboe the root dir.
+ NormalizePath(&input);
+ EXPECT_EQ("/foo", input);
+
+ input = "//../foo"; // Don't go aboe the root dir.
+ NormalizePath(&input);
+ EXPECT_EQ("//foo", input);
+
+ input = "../foo";
+ NormalizePath(&input);
+ EXPECT_EQ("../foo", input);
+
+ input = "..";
+ NormalizePath(&input);
+ EXPECT_EQ("..", input);
+
+ input = "./././.";
+ NormalizePath(&input);
+ EXPECT_EQ("", input);
+
+ input = "../../..";
+ NormalizePath(&input);
+ EXPECT_EQ("../../..", input);
+
+ input = "../";
+ NormalizePath(&input);
+ EXPECT_EQ("../", input);
+}
diff --git a/tools/gn/function_define_rule.cc b/tools/gn/function_define_rule.cc
new file mode 100644
index 0000000..afbed9e
--- /dev/null
+++ b/tools/gn/function_define_rule.cc
@@ -0,0 +1,37 @@
+// 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/functions.h"
+
+#include "tools/gn/parse_tree.h"
+#include "tools/gn/scope.h"
+#include "tools/gn/value.h"
+
+Value ExecuteDefineRule(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ BlockNode* block,
+ Err* err) {
+ // TODO(brettw) determine if the function is built-in and throw an error if
+ // it is.
+ if (args.size() != 1) {
+ *err = Err(function->function(),
+ "Need exactly one string arg to define_rule.");
+ return Value();
+ }
+ if (!args[0].VerifyTypeIs(Value::STRING, err))
+ return Value();
+ std::string rule_name = args[0].string_value();
+
+ const FunctionCallNode* existing_rule = scope->GetRule(rule_name);
+ if (existing_rule) {
+ *err = Err(function, "Duplicate rule definition.",
+ "A rule with this name was already defined.");
+ err->AppendSubErr(Err(existing_rule->function(), "Previous definition."));
+ return Value();
+ }
+
+ scope->AddRule(rule_name, function);
+ return Value();
+}
diff --git a/tools/gn/function_exec_script.cc b/tools/gn/function_exec_script.cc
new file mode 100644
index 0000000..a950909
--- /dev/null
+++ b/tools/gn/function_exec_script.cc
@@ -0,0 +1,254 @@
+// 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 "base/command_line.h"
+#include "base/file_util.h"
+#include "base/strings/string_number_conversions.h"
+#include "build/build_config.h"
+#include "tools/gn/err.h"
+#include "tools/gn/filesystem_utils.h"
+#include "tools/gn/functions.h"
+#include "tools/gn/input_conversion.h"
+#include "tools/gn/input_file.h"
+#include "tools/gn/parse_tree.h"
+#include "tools/gn/scheduler.h"
+#include "tools/gn/value.h"
+
+#if defined(OS_WIN)
+#include <windows.h>
+
+#include "base/win/scoped_handle.h"
+#include "base/win/scoped_process_information.h"
+#endif
+
+/*
+exec_script: Synchronously run a script and return the output.
+
+ exec_script(filename, arguments, input_conversion, [file_dependencies])
+
+ Runs the given script, returning the stdout of the script. The build
+ generation will fail if the script does not exist or returns a nonzero
+ exit code.
+
+Arguments:
+
+ filename:
+ File name of python script to execute, relative to the build file.
+
+ arguments:
+ A list of strings to be passed to the scripe as arguments.
+
+ input_conversion:
+ Controls how the file is read and parsed. See "help input_conversion".
+
+ dependencies:
+ (Optional) A list of files that this script reads or otherwise depends
+ on. These dependencies will be added to the build result such that if
+ any of them change, the build will be regenerated and the script will
+ be re-run.
+
+ The script itself will be an implicit dependency so you do not need to
+ list it.
+
+Example:
+
+ all_lines = exec_script("myscript.py", [some_input], "list lines",
+ ["data_file.txt"])
+*/
+
+namespace {
+
+#if defined(OS_WIN)
+bool ExecProcess(const CommandLine& cmdline,
+ const base::FilePath& startup_dir,
+ std::string* std_out,
+ std::string* std_err,
+ int* exit_code) {
+ SECURITY_ATTRIBUTES sa_attr;
+ // Set the bInheritHandle flag so pipe handles are inherited.
+ sa_attr.nLength = sizeof(SECURITY_ATTRIBUTES);
+ sa_attr.bInheritHandle = TRUE;
+ sa_attr.lpSecurityDescriptor = NULL;
+
+ // Create the pipe for the child process's STDOUT.
+ HANDLE out_read = NULL;
+ HANDLE out_write = NULL;
+ if (!CreatePipe(&out_read, &out_write, &sa_attr, 0)) {
+ NOTREACHED() << "Failed to create pipe";
+ return false;
+ }
+ base::win::ScopedHandle scoped_out_read(out_read);
+ base::win::ScopedHandle scoped_out_write(out_write);
+
+ // Create the pipe for the child process's STDERR.
+ HANDLE err_read = NULL;
+ HANDLE err_write = NULL;
+ if (!CreatePipe(&err_read, &err_write, &sa_attr, 0)) {
+ NOTREACHED() << "Failed to create pipe";
+ return false;
+ }
+ base::win::ScopedHandle scoped_err_read(err_read);
+ base::win::ScopedHandle scoped_err_write(err_write);
+
+ // Ensure the read handle to the pipe for STDOUT/STDERR is not inherited.
+ if (!SetHandleInformation(out_read, HANDLE_FLAG_INHERIT, 0)) {
+ NOTREACHED() << "Failed to disabled pipe inheritance";
+ return false;
+ }
+ if (!SetHandleInformation(err_read, HANDLE_FLAG_INHERIT, 0)) {
+ NOTREACHED() << "Failed to disabled pipe inheritance";
+ return false;
+ }
+
+ base::FilePath::StringType cmdline_str(cmdline.GetCommandLineString());
+
+ base::win::ScopedProcessInformation proc_info;
+ STARTUPINFO start_info = { 0 };
+
+ start_info.cb = sizeof(STARTUPINFO);
+ start_info.hStdOutput = out_write;
+ // Keep the normal stdin.
+ start_info.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
+ // FIXME(brettw) set stderr here when we actually read it below.
+ //start_info.hStdError = err_write;
+ start_info.hStdError = GetStdHandle(STD_ERROR_HANDLE);
+ start_info.dwFlags |= STARTF_USESTDHANDLES;
+
+ // Create the child process.
+ if (!CreateProcess(NULL,
+ &cmdline_str[0],
+ NULL, NULL,
+ TRUE, // Handles are inherited.
+ 0, NULL,
+ startup_dir.value().c_str(),
+ &start_info, proc_info.Receive())) {
+ return false;
+ }
+
+ // Close our writing end of pipes now. Otherwise later read would not be able
+ // to detect end of child's output.
+ scoped_out_write.Close();
+ scoped_err_write.Close();
+
+ // Read output from the child process's pipe for STDOUT
+ const int kBufferSize = 1024;
+ char buffer[kBufferSize];
+
+ // FIXME(brettw) read from stderr here! This is complicated because we want
+ // to read both of them at the same time, probably need overlapped I/O.
+ // Also uncomment start_info code above.
+ for (;;) {
+ DWORD bytes_read = 0;
+ BOOL success = ReadFile(out_read, buffer, kBufferSize, &bytes_read, NULL);
+ if (!success || bytes_read == 0)
+ break;
+ std_out->append(buffer, bytes_read);
+ }
+
+ // Let's wait for the process to finish.
+ WaitForSingleObject(proc_info.process_handle(), INFINITE);
+
+ DWORD dw_exit_code;
+ GetExitCodeProcess(proc_info.process_handle(), &dw_exit_code);
+ *exit_code = static_cast<int>(dw_exit_code);
+
+ return true;
+}
+#else
+bool ExecProcess(const CommandLine& cmdline,
+ const base::FilePath& startup_dir,
+ std::string* std_out,
+ std::string* std_err,
+ int* exit_code) {
+ //NOTREACHED() << "Implement me.";
+ return false;
+}
+#endif
+
+} // namespace
+
+Value ExecuteExecScript(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ Err* err) {
+ if (args.size() != 3 && args.size() != 4) {
+ *err = Err(function->function(), "Wrong number of args to write_file",
+ "I expected three or four arguments.");
+ return Value();
+ }
+
+ const Settings* settings = scope->settings();
+ const BuildSettings* build_settings = settings->build_settings();
+ const SourceDir& cur_dir = SourceDirForFunctionCall(function);
+
+ // Find the python script to run.
+ if (!args[0].VerifyTypeIs(Value::STRING, err))
+ return Value();
+ SourceFile script_source =
+ cur_dir.ResolveRelativeFile(args[0].string_value());
+ base::FilePath script_path = build_settings->GetFullPath(script_source);
+ if (!build_settings->secondary_source_path().empty() &&
+ !base::PathExists(script_path)) {
+ // Fall back to secondary source root when the file doesn't exist.
+ script_path = build_settings->GetFullPathSecondary(script_source);
+ }
+
+ // Add all dependencies of this script, including the script itself, to the
+ // build deps.
+ g_scheduler->AddGenDependency(script_source);
+ if (args.size() == 4) {
+ const Value& deps_value = args[3];
+ if (!deps_value.VerifyTypeIs(Value::LIST, err))
+ return Value();
+
+ for (size_t i = 0; i < deps_value.list_value().size(); i++) {
+ if (!deps_value.list_value()[0].VerifyTypeIs(Value::STRING, err))
+ return Value();
+ g_scheduler->AddGenDependency(cur_dir.ResolveRelativeFile(
+ deps_value.list_value()[0].string_value()));
+ }
+ }
+
+ // Make the command line.
+ const base::FilePath& python_path = build_settings->python_path();
+ CommandLine cmdline(python_path);
+ cmdline.AppendArgPath(script_path);
+
+ const Value& script_args = args[1];
+ if (!script_args.VerifyTypeIs(Value::LIST, err))
+ return Value();
+ for (size_t i = 0; i < script_args.list_value().size(); i++) {
+ if (!script_args.list_value()[i].VerifyTypeIs(Value::STRING, err))
+ return Value();
+ cmdline.AppendArg(script_args.list_value()[i].string_value());
+ }
+
+ // Execute the process.
+ // TODO(brettw) set the environment block.
+ std::string output;
+ std::string stderr_output; // TODO(brettw) not hooked up, see above.
+ int exit_code = 0;
+ if (!ExecProcess(cmdline, build_settings->GetFullPath(cur_dir),
+ &output, &stderr_output, &exit_code)) {
+ *err = Err(function->function(), "Could not execute python.",
+ "I was trying to execute \"" + FilePathToUTF8(python_path) + "\".");
+ return Value();
+ }
+
+ // TODO(brettw) maybe we need stderr also for reasonable stack dumps.
+ if (exit_code != 0) {
+ std::string msg =
+ std::string("I was running \"") + FilePathToUTF8(script_path) + "\"\n"
+ "and it returned " + base::IntToString(exit_code);
+ if (!output.empty())
+ msg += " and printed out:\n\n" + output;
+ else
+ msg += ".";
+ *err = Err(function->function(), "Script returned non-zero exit code.",
+ msg);
+ return Value();
+ }
+
+ return ConvertInputToValue(output, function, args[2], err);
+}
diff --git a/tools/gn/function_process_file_template.cc b/tools/gn/function_process_file_template.cc
new file mode 100644
index 0000000..18e1425
--- /dev/null
+++ b/tools/gn/function_process_file_template.cc
@@ -0,0 +1,65 @@
+// 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/file_template.h"
+#include "tools/gn/functions.h"
+#include "tools/gn/parse_tree.h"
+
+/*
+process_file_template: Do template expansion over a list of files.
+
+ process_file_template(source_list, template)
+
+ process_file_template applies a template list to a source file list,
+ returning the result of applying each template to each source. This is
+ typically used for computing output file names from input files.
+
+Arguments:
+
+ The source_list is a list of file names.
+
+ The template can be a string or a list. If it is a list, multiple output
+ strings are generated for each input.
+
+ The following template substrings are used in the template arguments
+ and are replaced with the corresponding part of the input file name:
+
+ "{{source}}": The entire source name.
+
+ "{{source_name_part}}": The source name with no path or extension.
+
+Example:
+
+ sources = [
+ "foo.idl",
+ "bar.idl",
+ ]
+ myoutputs = process_file_template(
+ sources,
+ [ "$target_gen_dir/{{source_name_part}}.cc",
+ "$target_gen_dir/{{source_name_part}}.h" ])
+
+ The result in this case will be:
+ [ "/out/Debug/foo.cc"
+ "/out/Debug/foo.h"
+ "/out/Debug/bar.cc"
+ "/out/Debug/bar.h" ]
+*/
+Value ExecuteProcessFileTemplate(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ Err* err) {
+ if (args.size() != 2) {
+ *err = Err(function->function(), "Expected two arguments");
+ return Value();
+ }
+
+ FileTemplate file_template(args[1], err);
+ if (err->has_error())
+ return Value();
+
+ Value ret(function, Value::LIST);
+ file_template.Apply(args[0], function, &ret.list_value(), err);
+ return ret;
+}
diff --git a/tools/gn/function_read_file.cc b/tools/gn/function_read_file.cc
new file mode 100644
index 0000000..db981ad
--- /dev/null
+++ b/tools/gn/function_read_file.cc
@@ -0,0 +1,67 @@
+// 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 "base/file_util.h"
+#include "tools/gn/err.h"
+#include "tools/gn/filesystem_utils.h"
+#include "tools/gn/functions.h"
+#include "tools/gn/input_conversion.h"
+#include "tools/gn/input_file.h"
+#include "tools/gn/scheduler.h"
+
+// TODO(brettw) consider removing this. I originally wrote it for making the
+// WebKit bindings but misundersood what was required, and didn't need to
+// use this. This seems to have a high potential for misuse.
+
+/*
+read_file: Read a file into a variable.
+
+ read_file(filename, how_to_read)
+
+ Whitespace will be trimmed from the end of the file. Throws an error if the
+ file can not be opened.
+
+Arguments:
+
+ filename:
+ Filename to read, relative to the build file.
+
+ input_conversion:
+ Controls how the file is read and parsed. See "help input_conversion".
+
+Example:
+
+ lines = read_file("foo.txt", "list lines")
+*/
+Value ExecuteReadFile(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ Err* err) {
+ if (args.size() != 2) {
+ *err = Err(function->function(), "Wrong number of args to read_file",
+ "I expected two arguments.");
+ return Value();
+ }
+ if (!args[0].VerifyTypeIs(Value::STRING, err))
+ return Value();
+
+ // Compute the file name.
+ const SourceDir& cur_dir = SourceDirForFunctionCall(function);
+ SourceFile source_file = cur_dir.ResolveRelativeFile(args[0].string_value());
+ base::FilePath file_path =
+ scope->settings()->build_settings()->GetFullPath(source_file);
+
+ // Ensure that everything is recomputed if the read file changes.
+ g_scheduler->AddGenDependency(source_file);
+
+ // Read contents.
+ std::string file_contents;
+ if (!file_util::ReadFileToString(file_path, &file_contents)) {
+ *err = Err(args[0], "Could not read file.",
+ "I resolved this to \"" + FilePathToUTF8(file_path) + "\".");
+ return Value();
+ }
+
+ return ConvertInputToValue(file_contents, function, args[1], err);
+}
diff --git a/tools/gn/function_set_default_toolchain.cc b/tools/gn/function_set_default_toolchain.cc
new file mode 100644
index 0000000..4939ac8
--- /dev/null
+++ b/tools/gn/function_set_default_toolchain.cc
@@ -0,0 +1,70 @@
+// 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/build_settings.h"
+#include "tools/gn/functions.h"
+#include "tools/gn/parse_tree.h"
+#include "tools/gn/scope.h"
+#include "tools/gn/settings.h"
+#include "tools/gn/toolchain_manager.h"
+
+/*
+set_default_toolchain: Sets the default toolchain name.
+
+ set_default_toolchain(toolchain_label)
+
+ The given label should identify a toolchain definition (see "toolchain").
+ This toolchain will be used for all targets unless otherwise specified.
+
+ This function is only valid to call during the processing of the build
+ configuration file. Since the build configuration file is processed
+ separately for each toolchain, this function will be a no-op when called
+ under any non-default toolchains.
+
+ For example, the default toolchain should be appropriate for the current
+ environment. If the current environment is 32-bit and somebody references
+ a target with a 64-bit toolchain, we wouldn't want processing of the build
+ config file for the 64-bit toolchain to reset the default toolchain to
+ 64-bit, we want to keep it 32-bits.
+
+Argument:
+
+ toolchain_label:
+ Toolchain name.
+
+Example:
+
+ set_default_toolchain("//build/config/win:vs32")
+*/
+
+Value ExecuteSetDefaultToolchain(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ Err* err) {
+ if (!scope->IsProcessingBuildConfig()) {
+ *err = Err(function->function(), "Must be called from build config.",
+ "set_default_toolchain can only be called from the build configuration "
+ "file.");
+ return Value();
+ }
+
+ // Ignore non-default-build-config invocations.
+ if (!scope->IsProcessingDefaultBuildConfig())
+ return Value();
+
+ const SourceDir& current_dir = SourceDirForFunctionCall(function);
+ const Label& default_toolchain = ToolchainLabelForScope(scope);
+
+ if (!EnsureSingleStringArg(function, args, err))
+ return Value();
+ Label toolchain_label(
+ Label::Resolve(current_dir, default_toolchain, args[0], err));
+ if (toolchain_label.is_null())
+ return Value();
+
+ ToolchainManager& mgr =
+ scope->settings()->build_settings()->toolchain_manager();
+ mgr.SetDefaultToolchainUnlocked(toolchain_label, function->GetRange(), err);
+ return Value();
+}
diff --git a/tools/gn/function_template.cc b/tools/gn/function_template.cc
new file mode 100644
index 0000000..a85a40f
--- /dev/null
+++ b/tools/gn/function_template.cc
@@ -0,0 +1,38 @@
+// 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/functions.h"
+
+#include "tools/gn/parse_tree.h"
+#include "tools/gn/scope.h"
+#include "tools/gn/value.h"
+
+Value ExecuteTemplate(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ BlockNode* block,
+ Err* err) {
+ // TODO(brettw) determine if the function is built-in and throw an error if
+ // it is.
+ if (args.size() != 1) {
+ *err = Err(function->function(),
+ "Need exactly one string arg to template.");
+ return Value();
+ }
+ if (!args[0].VerifyTypeIs(Value::STRING, err))
+ return Value();
+ std::string template_name = args[0].string_value();
+
+ const FunctionCallNode* existing_template = scope->GetTemplate(template_name);
+ if (existing_template) {
+ *err = Err(function, "Duplicate template definition.",
+ "A template with this name was already defined.");
+ err->AppendSubErr(Err(existing_template->function(),
+ "Previous definition."));
+ return Value();
+ }
+
+ scope->AddTemplate(template_name, function);
+ return Value();
+}
diff --git a/tools/gn/function_toolchain.cc b/tools/gn/function_toolchain.cc
new file mode 100644
index 0000000..b78c639
--- /dev/null
+++ b/tools/gn/function_toolchain.cc
@@ -0,0 +1,126 @@
+// 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/err.h"
+#include "tools/gn/functions.h"
+#include "tools/gn/parse_tree.h"
+#include "tools/gn/scheduler.h"
+#include "tools/gn/scope.h"
+#include "tools/gn/settings.h"
+#include "tools/gn/toolchain.h"
+
+namespace {
+
+// This is jsut a unique value to take the address of to use as the key for
+// the toolchain property on a scope.
+const int kToolchainPropertyKey = 0;
+
+// Reads the given string from the scope (if present) and puts the result into
+// dest. If the value is not a string, sets the error and returns false.
+bool ReadString(Scope& scope, const char* var, std::string* dest, Err* err) {
+ const Value* v = scope.GetValue(var, true);
+ if (!v)
+ return true; // Not present is fine.
+
+ if (!v->VerifyTypeIs(Value::STRING, err))
+ return false;
+ *dest = v->string_value();
+ return true;
+}
+
+} // namespace
+
+Value ExecuteToolchain(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ BlockNode* block,
+ Err* err) {
+ if (!EnsureNotProcessingImport(function, scope, err) ||
+ !EnsureNotProcessingBuildConfig(function, scope, err))
+ return Value();
+
+ // Note that we don't want to use MakeLabelForScope since that will include
+ // the toolchain name in the label, and toolchain labels don't themselves
+ // have toolchain names.
+ const SourceDir& input_dir = SourceDirForFunctionCall(function);
+ Label label(input_dir, args[0].string_value(), SourceDir(), std::string());
+ if (g_scheduler->verbose_logging())
+ g_scheduler->Log("Generating toolchain", label.GetUserVisibleName(true));
+
+ // This object will actually be copied into the one owned by the toolchain
+ // manager, but that has to be done in the lock.
+ Toolchain toolchain(label);
+
+ Scope block_scope(scope);
+ block_scope.SetProperty(&kToolchainPropertyKey, &toolchain);
+ block->ExecuteBlockInScope(&block_scope, err);
+ block_scope.SetProperty(&kToolchainPropertyKey, NULL);
+ if (err->has_error())
+ return Value();
+ if (!block_scope.CheckForUnusedVars(err))
+ return Value();
+
+ const BuildSettings* build_settings = scope->settings()->build_settings();
+ {
+ // Save the toolchain definition in the toolchain manager and mark the
+ // corresponding item in the dependency tree resolved so that targets
+ // that depend on this toolchain know it's ready.
+ base::AutoLock lock(build_settings->item_tree().lock());
+ build_settings->toolchain_manager().SetToolchainDefinitionLocked(
+ toolchain, function->GetRange(), err);
+ build_settings->item_tree().MarkItemGeneratedLocked(label);
+ }
+ return Value();
+}
+
+Value ExecuteTool(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ BlockNode* block,
+ Err* err) {
+ // Find the toolchain definition we're executing inside of. The toolchain
+ // function will set a property pointing to it that we'll pick up.
+ Toolchain* toolchain = reinterpret_cast<Toolchain*>(
+ scope->GetProperty(&kToolchainPropertyKey, NULL));
+ if (!toolchain) {
+ *err = Err(function->function(), "tool() called outside of toolchain().",
+ "The tool() function can only be used inside a toolchain() "
+ "definition.");
+ return Value();
+ }
+
+ if (!EnsureSingleStringArg(function, args, err))
+ return Value();
+ const std::string& tool_name = args[0].string_value();
+ Toolchain::ToolType tool_type = Toolchain::ToolNameToType(tool_name);
+ if (tool_type == Toolchain::TYPE_NONE) {
+ *err = Err(args[0], "Unknown tool type");
+ return Value();
+ }
+
+ // Run the tool block.
+ Scope block_scope(scope);
+ block->ExecuteBlockInScope(&block_scope, err);
+ if (err->has_error())
+ return Value();
+
+ // Extract the stuff we need.
+ Toolchain::Tool t;
+ if (!ReadString(block_scope, "command", &t.command, err) ||
+ !ReadString(block_scope, "depfile", &t.depfile, err) ||
+ !ReadString(block_scope, "deps", &t.deps, err) ||
+ !ReadString(block_scope, "description", &t.description, 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))
+ return Value();
+
+ // Make sure there weren't any vars set in this tool that were unused.
+ if (!block_scope.CheckForUnusedVars(err))
+ return Value();
+
+ toolchain->SetTool(tool_type, t);
+ return Value();
+}
diff --git a/tools/gn/function_write_file.cc b/tools/gn/function_write_file.cc
new file mode 100644
index 0000000..9356feb
--- /dev/null
+++ b/tools/gn/function_write_file.cc
@@ -0,0 +1,84 @@
+// 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 <iostream>
+#include <sstream>
+
+#include "base/file_util.h"
+#include "base/strings/string_split.h"
+#include "base/strings/string_util.h"
+#include "tools/gn/err.h"
+#include "tools/gn/filesystem_utils.h"
+#include "tools/gn/functions.h"
+#include "tools/gn/input_file.h"
+#include "tools/gn/parse_tree.h"
+#include "tools/gn/scheduler.h"
+
+/*
+write_file: Read a file into a variable.
+
+ write_file(filename, data)
+
+ If data is a list, the list will be written one-item-per-line with no
+ quoting or brackets.
+
+ TODO(brettw) we probably need an optional third argument to control list
+ formatting.
+
+Arguments:
+
+ filename:
+ Filename to write. This must be within the output directory.
+
+ data:
+ The list or string to write.
+*/
+Value ExecuteWriteFile(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ Err* err) {
+ if (args.size() != 2) {
+ *err = Err(function->function(), "Wrong number of args to write_file",
+ "I expected two arguments.");
+ return Value();
+ }
+
+ // Compute the file name and make sure it's in the output dir.
+ if (!args[0].VerifyTypeIs(Value::STRING, err))
+ return Value();
+ const SourceDir& cur_dir = SourceDirForFunctionCall(function);
+ SourceFile source_file = cur_dir.ResolveRelativeFile(args[0].string_value());
+ if (!EnsureStringIsInOutputDir(
+ scope->settings()->build_settings()->build_dir(),
+ source_file.value(), args[0], err))
+ return Value();
+
+ // Compute output.
+ std::ostringstream contents;
+ if (args[1].type() == Value::LIST) {
+ const std::vector<Value>& list = args[1].list_value();
+ for (size_t i = 0; i < list.size(); i++)
+ contents << list[i].ToString() << std::endl;
+ } else {
+ contents << args[1].ToString();
+ }
+
+ // Write file, creating the directory if necessary.
+ base::FilePath file_path =
+ scope->settings()->build_settings()->GetFullPath(source_file);
+ const std::string& contents_string = contents.str();
+ if (!file_util::CreateDirectory(file_path.DirName())) {
+ *err = Err(function->function(), "Unable to create directory.",
+ "I was using \"" + FilePathToUTF8(file_path.DirName()) + "\".");
+ return Value();
+ }
+ if (file_util::WriteFile(file_path,
+ contents_string.c_str(), contents_string.size())
+ != static_cast<int>(contents_string.size())) {
+ *err = Err(function->function(), "Unable to write file.",
+ "I was writing \"" + FilePathToUTF8(file_path) + "\".");
+ return Value();
+ }
+ return Value();
+}
diff --git a/tools/gn/functions.cc b/tools/gn/functions.cc
new file mode 100644
index 0000000..7f32db2
--- /dev/null
+++ b/tools/gn/functions.cc
@@ -0,0 +1,443 @@
+// 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/functions.h"
+
+#include <iostream>
+
+#include "base/strings/string_util.h"
+#include "tools/gn/config.h"
+#include "tools/gn/config_values_generator.h"
+#include "tools/gn/err.h"
+#include "tools/gn/input_file.h"
+#include "tools/gn/item_tree.h"
+#include "tools/gn/parse_tree.h"
+#include "tools/gn/scheduler.h"
+#include "tools/gn/scope.h"
+#include "tools/gn/settings.h"
+#include "tools/gn/target_manager.h"
+#include "tools/gn/token.h"
+#include "tools/gn/value.h"
+
+namespace {
+
+void FillNeedsBlockError(const FunctionCallNode* function, Err* err) {
+ *err = Err(function->function(), "This function call requires a block.",
+ "The block's \"{\" must be on the same line as the function "
+ "call's \")\".");
+}
+
+Value ExecuteAssert(const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ Err* err) {
+ if (args.size() != 1) {
+ *err = Err(function->function(), "Wrong number of arguments.",
+ "assert() takes one argument, "
+ "were you expecting somethig else?");
+ } else if (args[0].InterpretAsInt() == 0) {
+ *err = Err(function->function(), "Assertion failed.");
+ if (args[0].origin()) {
+ // If you do "assert(foo)" we'd ideally like to show you where foo was
+ // set, and in this case the origin of the args will tell us that.
+ // However, if you do "assert(foo && bar)" the source of the value will
+ // be the assert like, which isn't so helpful.
+ //
+ // So we try to see if the args are from the same line or not. This will
+ // break if you do "assert(\nfoo && bar)" and we may show the second line
+ // as the source, oh well. The way around this is to check to see if the
+ // origin node is inside our function call block.
+ Location origin_location = args[0].origin()->GetRange().begin();
+ if (origin_location.file() != function->function().location().file() ||
+ origin_location.line_number() !=
+ function->function().location().line_number()) {
+ err->AppendSubErr(Err(args[0].origin()->GetRange(), "",
+ "This is where it was set."));
+ }
+ }
+ }
+ return Value();
+}
+
+Value ExecuteConfig(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ Err* err) {
+ if (!EnsureSingleStringArg(function, args, err) ||
+ !EnsureNotProcessingImport(function, scope, err))
+ return Value();
+
+ Label label(MakeLabelForScope(scope, function, args[0].string_value()));
+
+ if (g_scheduler->verbose_logging())
+ g_scheduler->Log("Generating config", label.GetUserVisibleName(true));
+
+ // Create the empty config object.
+ ItemTree* tree = &scope->settings()->build_settings()->item_tree();
+ Config* config = Config::GetConfig(scope->settings(), function->GetRange(),
+ label, NULL, err);
+ if (err->has_error())
+ return Value();
+
+ // Fill it.
+ const SourceDir input_dir = SourceDirForFunctionCall(function);
+ ConfigValuesGenerator gen(&config->config_values(), scope,
+ function->function(), input_dir, err);
+ gen.Run();
+ if (err->has_error())
+ return Value();
+
+ // Mark as complete.
+ {
+ base::AutoLock lock(tree->lock());
+ tree->MarkItemGeneratedLocked(label);
+ }
+ return Value();
+}
+
+Value ExecuteDeclareArgs(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ Err* err) {
+ // Only allow this to be called once. We use a variable in the current scope
+ // with a name the parser will reject if the user tried to type it.
+ const char did_declare_args_var[] = "@@declared_args";
+ if (scope->GetValue(did_declare_args_var)) {
+ *err = Err(function->function(), "Duplicate call to declared_args.");
+ err->AppendSubErr(
+ Err(scope->GetValue(did_declare_args_var)->origin()->GetRange(),
+ "See the original call."));
+ return Value();
+ }
+
+ // Find the root scope where the values will be set.
+ Scope* root = scope->mutable_containing();
+ if (!root || root->containing() || !scope->IsProcessingBuildConfig()) {
+ *err = Err(function->function(), "declare_args called incorrectly."
+ "It must be called only from the build config script and in the "
+ "root scope.");
+ return Value();
+ }
+
+ // Take all variables set in the current scope as default values and put
+ // them in the parent scope. The values in the current scope are the defaults,
+ // then we apply the external args to this list.
+ Scope::KeyValueVector values;
+ scope->GetCurrentScopeValues(&values);
+ for (size_t i = 0; i < values.size(); i++) {
+ // TODO(brettw) actually import the arguments from the command line rather
+ // than only using the defaults.
+ root->SetValue(values[i].first, values[i].second,
+ values[i].second.origin());
+ }
+
+ scope->SetValue(did_declare_args_var, Value(function, 1), NULL);
+ return Value();
+}
+
+Value ExecuteImport(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ Err* err) {
+ if (!EnsureSingleStringArg(function, args, err) ||
+ !EnsureNotProcessingImport(function, scope, err))
+ return Value();
+
+ const SourceDir input_dir = SourceDirForFunctionCall(function);
+ SourceFile import_file =
+ input_dir.ResolveRelativeFile(args[0].string_value());
+ scope->settings()->import_manager().DoImport(import_file, function,
+ scope, err);
+ return Value();
+}
+
+Value ExecuteTemplate(Scope* scope,
+ const FunctionCallNode* invocation,
+ const std::vector<Value>& args,
+ BlockNode* block,
+ const FunctionCallNode* rule,
+ Err* err) {
+ if (!EnsureNotProcessingImport(invocation, scope, err))
+ return Value();
+ Scope block_scope(scope);
+ if (!FillTargetBlockScope(scope, invocation,
+ invocation->function().value().data(),
+ block, args, &block_scope, err))
+ return Value();
+
+ // Run the block for the rule invocation.
+ block->ExecuteBlockInScope(&block_scope, err);
+ if (err->has_error())
+ return Value();
+
+ // Now run the rule itself with that block as the current scope.
+ rule->block()->ExecuteBlockInScope(&block_scope, err);
+ if (err->has_error())
+ return Value();
+
+ return Value();
+}
+
+Value ExecuteSetDefaults(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ BlockNode* block,
+ Err* err) {
+ if (!EnsureSingleStringArg(function, args, err))
+ return Value();
+ const std::string& target_type(args[0].string_value());
+
+ // Ensure there aren't defaults already set.
+ if (scope->GetTargetDefaults(target_type)) {
+ *err = Err(function->function(),
+ "This target type defaults were already set.");
+ return Value();
+ }
+
+ // Execute the block in a new scope that has a parent of the containing
+ // scope.
+ Scope block_scope(scope);
+ if (!FillTargetBlockScope(scope, function,
+ function->function().value().data(),
+ block, args, &block_scope, err))
+ return Value();
+
+ // Run the block for the rule invocation.
+ block->ExecuteBlockInScope(&block_scope, err);
+ if (err->has_error())
+ return Value();
+
+ // Now copy the values set on the scope we made into the free-floating one
+ // (with no containing scope) used to hold the target defaults.
+ Scope* dest = scope->MakeTargetDefaults(target_type);
+ block_scope.NonRecursiveMergeTo(dest, function, "<SHOULD NOT FAIL>", err);
+ return Value();
+}
+
+Value ExecuteSetSourcesAssignmentFilter(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ Err* err) {
+ if (args.size() != 1) {
+ *err = Err(function, "set_sources_assignment_filter takes one argument.");
+ } else {
+ scoped_ptr<PatternList> f(new PatternList);
+ f->SetFromValue(args[0], err);
+ if (!err->has_error())
+ scope->set_sources_assignment_filter(f.Pass());
+ }
+ return Value();
+}
+
+// void print(...)
+// prints all arguments to the console separated by spaces.
+Value ExecutePrint(const std::vector<Value>& args, Err* err) {
+ for (size_t i = 0; i < args.size(); i++) {
+ if (i != 0)
+ std::cout << " ";
+ std::cout << args[i].ToString();
+ }
+ std::cout << std::endl;
+ return Value();
+}
+
+} // namespace
+
+// ----------------------------------------------------------------------------
+
+namespace functions {
+
+const char kAssert[] = "assert";
+const char kComponent[] = "component";
+const char kConfig[] = "config";
+const char kCopy[] = "copy";
+const char kCustom[] = "custom";
+const char kDeclareArgs[] = "declare_args";
+const char kExecScript[] = "exec_script";
+const char kExecutable[] = "executable";
+const char kGroup[] = "group";
+const char kImport[] = "import";
+const char kPrint[] = "print";
+const char kProcessFileTemplate[] = "process_file_template";
+const char kReadFile[] = "read_file";
+const char kSetDefaults[] = "set_defaults";
+const char kSetDefaultToolchain[] = "set_default_toolchain";
+const char kSetSourcesAssignmentFilter[] = "set_sources_assignment_filter";
+const char kSharedLibrary[] = "shared_library";
+const char kStaticLibrary[] = "static_library";
+const char kTemplate[] = "template";
+const char kTool[] = "tool";
+const char kToolchain[] = "toolchain";
+const char kTest[] = "test";
+const char kWriteFile[] = "write_file";
+
+} // namespace functions
+
+// ----------------------------------------------------------------------------
+
+bool EnsureNotProcessingImport(const ParseNode* node,
+ const Scope* scope,
+ Err* err) {
+ if (scope->IsProcessingImport()) {
+ *err = Err(node, "Not valid from an import.",
+ "We need to talk about this thing you are doing here. Doing this\n"
+ "kind of thing from an imported file makes me feel like you are\n"
+ "abusing me. Imports are for defining defaults, variables, and rules.\n"
+ "The appropriate place for this kind of thing is really in a normal\n"
+ "BUILD file.");
+ return false;
+ }
+ return true;
+}
+
+bool EnsureNotProcessingBuildConfig(const ParseNode* node,
+ const Scope* scope,
+ Err* err) {
+ if (scope->IsProcessingBuildConfig()) {
+ *err = Err(node, "Not valid from the build config.",
+ "You can't do this kind of thing from the build config script, "
+ "silly!\nPut it in a regular BUILD file.");
+ return false;
+ }
+ return true;
+}
+
+bool FillTargetBlockScope(const Scope* scope,
+ const FunctionCallNode* function,
+ const char* target_type,
+ const BlockNode* block,
+ const std::vector<Value>& args,
+ Scope* block_scope,
+ Err* err) {
+ if (!block) {
+ FillNeedsBlockError(function, err);
+ return false;
+ }
+
+ // Copy the target defaults, if any, into the scope we're going to execute
+ // the block in.
+ const Scope* default_scope = scope->GetTargetDefaults(target_type);
+ if (default_scope) {
+ if (!default_scope->NonRecursiveMergeTo(block_scope, function,
+ "target defaults", err))
+ return false;
+ }
+
+ // The name is the single argument to the target function.
+ if (!EnsureSingleStringArg(function, args, err))
+ return false;
+
+ // Set the target name variable to the current target, and mark it used
+ // because we don't want to issue an error if the script ignores it.
+ const base::StringPiece target_name("target_name");
+ block_scope->SetValue(target_name, Value(function, args[0].string_value()),
+ function);
+ block_scope->MarkUsed(target_name);
+ return true;
+}
+
+bool EnsureSingleStringArg(const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ Err* err) {
+ if (args.size() != 1) {
+ *err = Err(function->function(), "Incorrect arguments.",
+ "This function requires a single string argument.");
+ return false;
+ }
+ return args[0].VerifyTypeIs(Value::STRING, err);
+}
+
+const SourceDir& SourceDirForFunctionCall(const FunctionCallNode* function) {
+ return function->function().location().file()->dir();
+}
+
+const Label& ToolchainLabelForScope(const Scope* scope) {
+ return scope->settings()->toolchain()->label();
+}
+
+Label MakeLabelForScope(const Scope* scope,
+ const FunctionCallNode* function,
+ const std::string& name) {
+ const SourceDir& input_dir = SourceDirForFunctionCall(function);
+ const Label& toolchain_label = ToolchainLabelForScope(scope);
+ return Label(input_dir, name, toolchain_label.dir(), toolchain_label.name());
+}
+
+Value ExecuteFunction(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ BlockNode* block,
+ Err* err) {
+ const Token& name = function->function();
+ if (block) {
+ // These target generators need to execute the block themselves.
+ if (name.IsIdentifierEqualTo(functions::kComponent))
+ return ExecuteComponent(scope, function, args, block, err);
+ if (name.IsIdentifierEqualTo(functions::kCustom))
+ return ExecuteCustom(scope, function, args, block, err);
+ if (name.IsIdentifierEqualTo(functions::kExecutable))
+ return ExecuteExecutable(scope, function, args, block, err);
+ if (name.IsIdentifierEqualTo(functions::kSetDefaults))
+ return ExecuteSetDefaults(scope, function, args, block, err);
+ if (name.IsIdentifierEqualTo(functions::kSharedLibrary))
+ return ExecuteSharedLibrary(scope, function, args, block, err);
+ if (name.IsIdentifierEqualTo(functions::kStaticLibrary))
+ return ExecuteStaticLibrary(scope, function, args, block, err);
+ if (name.IsIdentifierEqualTo(functions::kGroup))
+ return ExecuteGroup(scope, function, args, block, err);
+ if (name.IsIdentifierEqualTo(functions::kTest))
+ return ExecuteExecutable(scope, function, args, block, err);
+ if (name.IsIdentifierEqualTo(functions::kTemplate))
+ return ExecuteTemplate(scope, function, args, block, err);
+ if (name.IsIdentifierEqualTo(functions::kTool))
+ return ExecuteTool(scope, function, args, block, err);
+ if (name.IsIdentifierEqualTo(functions::kToolchain))
+ return ExecuteToolchain(scope, function, args, block, err);
+
+ const FunctionCallNode* rule =
+ scope->GetTemplate(function->function().value().as_string());
+ if (rule)
+ return ExecuteTemplate(scope, function, args, block, rule, err);
+
+ // FIXME(brettw) This is not right, what if you specify a function that
+ // doesn't take a block but specify one?!?!?
+
+ // The rest of the functions can take a pre-executed block for simplicity.
+ Scope block_scope(scope);
+ block->ExecuteBlockInScope(&block_scope, err);
+ if (err->has_error())
+ return Value();
+
+ if (name.IsIdentifierEqualTo(functions::kConfig))
+ return ExecuteConfig(&block_scope, function, args, err);
+ if (name.IsIdentifierEqualTo(functions::kCopy))
+ return ExecuteCopy(&block_scope, function, args, err);
+ if (name.IsIdentifierEqualTo(functions::kDeclareArgs))
+ return ExecuteDeclareArgs(&block_scope, function, args, err);
+
+ *err = Err(name, "Unknown function.");
+ return Value();
+ }
+
+ if (name.IsIdentifierEqualTo(functions::kAssert))
+ return ExecuteAssert(function, args, err);
+ if (name.IsIdentifierEqualTo(functions::kExecScript))
+ return ExecuteExecScript(scope, function, args, err);
+ if (name.IsIdentifierEqualTo(functions::kImport))
+ return ExecuteImport(scope, function, args, err);
+ if (name.IsIdentifierEqualTo(functions::kPrint))
+ return ExecutePrint(args, err);
+ if (name.IsIdentifierEqualTo(functions::kProcessFileTemplate))
+ return ExecuteProcessFileTemplate(scope, function, args, err);
+ if (name.IsIdentifierEqualTo(functions::kReadFile))
+ return ExecuteReadFile(scope, function, args, err);
+ if (name.IsIdentifierEqualTo(functions::kSetDefaultToolchain))
+ return ExecuteSetDefaultToolchain(scope, function, args, err);
+ if (name.IsIdentifierEqualTo(functions::kSetSourcesAssignmentFilter))
+ return ExecuteSetSourcesAssignmentFilter(scope, function, args, err);
+ if (name.IsIdentifierEqualTo(functions::kWriteFile))
+ return ExecuteWriteFile(scope, function, args, err);
+
+ *err = Err(function, "Unknown function.");
+ return Value();
+}
diff --git a/tools/gn/functions.h b/tools/gn/functions.h
new file mode 100644
index 0000000..806de1d
--- /dev/null
+++ b/tools/gn/functions.h
@@ -0,0 +1,182 @@
+// 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_FUNCTIONS_H_
+#define TOOLS_GN_FUNCTIONS_H_
+
+#include <string>
+#include <vector>
+
+class Err;
+class BlockNode;
+class FunctionCallNode;
+class Label;
+class ListNode;
+class ParseNode;
+class Scope;
+class SourceDir;
+class Token;
+class Value;
+
+Value ExecuteFunction(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ BlockNode* block, // Optional.
+ Err* err);
+
+// Function executing functions -----------------------------------------------
+
+Value ExecuteTemplate(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ BlockNode* block,
+ Err* err);
+Value ExecuteExecScript(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ Err* err);
+Value ExecuteProcessFileTemplate(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ Err* err);
+Value ExecuteReadFile(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ Err* err);
+Value ExecuteSetDefaultToolchain(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ Err* err);
+Value ExecuteTool(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ BlockNode* block,
+ Err* err);
+Value ExecuteToolchain(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ BlockNode* block,
+ Err* err);
+Value ExecuteWriteFile(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ Err* err);
+
+// Target-generating functions.
+Value ExecuteComponent(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ BlockNode* block,
+ Err* err);
+Value ExecuteCopy(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ Err* err);
+Value ExecuteCustom(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ BlockNode* block,
+ Err* err);
+Value ExecuteExecutable(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ BlockNode* block,
+ Err* err);
+Value ExecuteSharedLibrary(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ BlockNode* block,
+ Err* err);
+Value ExecuteStaticLibrary(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ BlockNode* block,
+ Err* err);
+Value ExecuteGroup(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ BlockNode* block,
+ Err* err);
+
+// Helper functions -----------------------------------------------------------
+
+// Verifies that the current scope is not processing an import. If it is, it
+// will set the error, blame the given parse node for it, and return false.
+bool EnsureNotProcessingImport(const ParseNode* node,
+ const Scope* scope,
+ Err* err);
+
+// Like EnsureNotProcessingImport but checks for running the build config.
+bool EnsureNotProcessingBuildConfig(const ParseNode* node,
+ const Scope* scope,
+ Err* err);
+
+// Sets up the |block_scope| for executing a target (or something like it).
+// The |scope| is the containing scope. It should have been already set as the
+// parent for the |block_scope| when the |block_scope| was created.
+//
+// This will set up the target defaults and set the |target_name| variable in
+// the block scope to the current target name, which is assumed to be the first
+// argument to the function.
+//
+// On success, returns true. On failure, sets the error and returns false.
+bool FillTargetBlockScope(const Scope* scope,
+ const FunctionCallNode* function,
+ const char* target_type,
+ const BlockNode* block,
+ const std::vector<Value>& args,
+ Scope* block_scope,
+ Err* err);
+
+// Validates that the given function call has one string argument. This is
+// the most common function signature, so it saves space to have this helper.
+// Returns false and sets the error on failure.
+bool EnsureSingleStringArg(const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ Err* err);
+
+// Returns the source directory for the file comtaining the given function
+// invocation.
+const SourceDir& SourceDirForFunctionCall(const FunctionCallNode* function);
+
+// Returns the name of the toolchain for the given scope.
+const Label& ToolchainLabelForScope(const Scope* scope);
+
+// Generates a label for the given scope, using the current directory and
+// toolchain, and the given name.
+Label MakeLabelForScope(const Scope* scope,
+ const FunctionCallNode* function,
+ const std::string& name);
+
+// Function name constants ----------------------------------------------------
+
+namespace functions {
+
+extern const char kAssert[];
+extern const char kComponent[];
+extern const char kConfig[];
+extern const char kCopy[];
+extern const char kCustom[];
+extern const char kDeclareArgs[];
+extern const char kExecScript[];
+extern const char kExecutable[];
+extern const char kGroup[];
+extern const char kImport[];
+extern const char kPrint[];
+extern const char kProcessFileTemplate[];
+extern const char kReadFile[];
+extern const char kSetDefaults[];
+extern const char kSetDefaultToolchain[];
+extern const char kSetSourcesAssignmentFilter[];
+extern const char kSharedLibrary[];
+extern const char kStaticLibrary[];
+extern const char kTemplate[];
+extern const char kTest[];
+extern const char kTool[];
+extern const char kToolchain[];
+extern const char kWriteFile[];
+
+} // namespace functions
+
+#endif // TOOLS_GN_FUNCTIONS_H_
diff --git a/tools/gn/functions_target.cc b/tools/gn/functions_target.cc
new file mode 100644
index 0000000..a5991e7
--- /dev/null
+++ b/tools/gn/functions_target.cc
@@ -0,0 +1,221 @@
+// 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/functions.h"
+
+#include "tools/gn/err.h"
+#include "tools/gn/parse_tree.h"
+#include "tools/gn/scope.h"
+#include "tools/gn/target_generator.h"
+#include "tools/gn/value.h"
+
+namespace {
+
+Value ExecuteGenericTarget(const char* target_type,
+ Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ BlockNode* block,
+ Err* err) {
+ if (!EnsureNotProcessingImport(function, scope, err) ||
+ !EnsureNotProcessingBuildConfig(function, scope, err))
+ return Value();
+ Scope block_scope(scope);
+ if (!FillTargetBlockScope(scope, function, target_type, block,
+ args, &block_scope, err))
+ return Value();
+
+ block->ExecuteBlockInScope(&block_scope, err);
+ if (err->has_error())
+ return Value();
+
+ TargetGenerator::GenerateTarget(&block_scope, function->function(), args,
+ target_type, err);
+
+ block_scope.CheckForUnusedVars(err);
+ return Value();
+}
+
+} // namespace
+
+Value ExecuteComponent(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ BlockNode* block,
+ Err* err) {
+ // A component is either a shared or static library, depending on the value
+ // of |component_mode|.
+ const Value* component_mode_value = scope->GetValue("component_mode");
+
+ static const char helptext[] =
+ "You're declaring a component here but have not defined "
+ "\"component_mode\" to\neither \"shared_library\" or \"static_library\".";
+ if (!component_mode_value) {
+ *err = Err(function->function(), "No component mode set.", helptext);
+ return Value();
+ }
+ if (component_mode_value->type() != Value::STRING ||
+ (component_mode_value->string_value() != functions::kSharedLibrary &&
+ component_mode_value->string_value() != functions::kStaticLibrary)) {
+ *err = Err(function->function(), "Invalid component mode set.", helptext);
+ return Value();
+ }
+ const std::string& component_mode = component_mode_value->string_value();
+
+ if (!EnsureNotProcessingImport(function, scope, err))
+ return Value();
+ Scope block_scope(scope);
+ if (!FillTargetBlockScope(scope, function, component_mode.c_str(), block,
+ args, &block_scope, err))
+ return Value();
+
+ block->ExecuteBlockInScope(&block_scope, err);
+ if (err->has_error())
+ return Value();
+
+ TargetGenerator::GenerateTarget(&block_scope, function->function(), args,
+ component_mode, err);
+ return Value();
+}
+
+Value ExecuteCopy(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ Err* err) {
+ if (!EnsureNotProcessingImport(function, scope, err) ||
+ !EnsureNotProcessingBuildConfig(function, scope, err))
+ return Value();
+ TargetGenerator::GenerateTarget(scope, function->function(), args,
+ functions::kCopy, err);
+ return Value();
+}
+
+/*
+custom: Declare a script-generated target.
+
+ This target type allows you to run a script over a set of sources files and
+ generate a set of output files.
+
+ The script will be executed with the given arguments with the current
+ directory being that of the current BUILD file.
+
+ There are two modes. The first mode is the "per-file" mode where you
+ specify a list of sources and the script is run once for each one as a build
+ rule. In this case, each file specified in the |outputs| variable must be
+ unique when applied to each source file (normally you would reference
+ "{{source_name_part}}" from within each one) or the build system will get
+ confused about how to build those files. You should use the |data| variable
+ to list all additional dependencies of your script: these will be added
+ as dependencies for each build step.
+
+ The second mode is when you just want to run a script once rather than as a
+ general rule over a set of files. In this case you don't list any sources.
+ Dependencies of your script are specified only in the |data| variable and
+ your |outputs| variable should just list all outputs.
+
+Variables:
+
+ args, data, deps, outputs, script*, sources
+ * = required
+
+ There are some special substrings that will be searched for when processing
+ some variables:
+
+ "{{source}}"
+ Expanded in |args|, this is the name of the source file relative to the
+ current directory when running the script. This is how you specify
+ the current input file to your script.
+
+ "{{source_name_part}}"
+ Expanded in |args| and |outputs|, this is just the filename part of the
+ current source file with no directory or extension. This is how you
+ specify a name transoformation to the output. Normally you would
+ write an output as "$target_output_dir/{{source_name_part}}.o".
+
+ All |outputs| files must be inside the output directory of the build. You
+ would generally use "$target_output_dir" or "$target_gen_dir" to reference
+ the output or generated intermediate file directories, respectively.
+
+Examples:
+
+ custom("general_rule") {
+ script = "do_processing.py"
+ sources = [ "foo.idl" ]
+ data = [ "my_configuration.txt" ]
+ outputs = [ "$target_gen_dir/{{source_name_part}}.h" ]
+ args = [ "{{source}}",
+ "-o", "$relative_target_gen_dir/{{source_name_part}}.h" ]
+ }
+
+ custom("just_run_this_guy_once") {
+ script = "doprocessing.py"
+ data = [ "my_configuration.txt" ]
+ outputs = [ "$target_gen_dir/insightful_output.txt" ]
+ args = [ "--output_dir", $target_gen_dir ]
+ }
+*/
+Value ExecuteCustom(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ BlockNode* block,
+ Err* err) {
+ return ExecuteGenericTarget(functions::kCustom, scope, function, args,
+ block, err);
+}
+
+Value ExecuteExecutable(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ BlockNode* block,
+ Err* err) {
+ return ExecuteGenericTarget(functions::kExecutable, scope, function, args,
+ block, err);
+}
+
+Value ExecuteSharedLibrary(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ BlockNode* block,
+ Err* err) {
+ return ExecuteGenericTarget(functions::kSharedLibrary, scope, function, args,
+ block, err);
+}
+
+Value ExecuteStaticLibrary(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ BlockNode* block,
+ Err* err) {
+ return ExecuteGenericTarget(functions::kStaticLibrary, scope, function, args,
+ block, err);
+}
+
+/*
+group: Declare a group of targets.
+
+ This target type allows you to create meta-targets that just collect a set
+ of dependencies into one named target.
+
+Variables:
+
+ deps
+
+Example:
+
+ group("all") {
+ deps = [
+ "//project:runner",
+ "//project:unit_tests",
+ ]
+ }
+*/
+Value ExecuteGroup(Scope* scope,
+ const FunctionCallNode* function,
+ const std::vector<Value>& args,
+ BlockNode* block,
+ Err* err) {
+ return ExecuteGenericTarget(functions::kGroup, scope, function, args,
+ block, err);
+}
+
diff --git a/tools/gn/generate_test_gn_data.cc b/tools/gn/generate_test_gn_data.cc
new file mode 100644
index 0000000..017c4c4
--- /dev/null
+++ b/tools/gn/generate_test_gn_data.cc
@@ -0,0 +1,129 @@
+// 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 <fstream>
+#include <iostream>
+
+#include "base/file_util.h"
+#include "base/files/file_path.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/utf_string_conversions.h"
+#include "build/build_config.h"
+
+// Usage: just run in the directory where you want your test source root to be.
+
+int files_written = 0;
+int targets_written = 0;
+
+base::FilePath UTF8ToFilePath(const std::string& s) {
+#if defined(OS_WIN)
+ return base::FilePath(UTF8ToWide(s));
+#else
+ return base::FilePath(s);
+#endif
+}
+
+std::string FilePathToUTF8(const base::FilePath& path) {
+#if defined(OS_WIN)
+ return WideToUTF8(path.value());
+#else
+ return path.value();
+#endif
+}
+
+base::FilePath RepoPathToPathName(const std::vector<int>& repo_path) {
+ base::FilePath ret;
+ for (size_t i = 0; i < repo_path.size(); i++) {
+ ret = ret.Append(UTF8ToFilePath(base::IntToString(repo_path[i])));
+ }
+ return ret;
+}
+
+std::string TargetIndexToLetter(int target_index) {
+ char ret[2];
+ ret[0] = 'a' + target_index;
+ ret[1] = 0;
+ return ret;
+}
+
+std::string RepoPathToTargetName(const std::vector<int>& repo_path,
+ int target_index) {
+ std::string ret;
+ for (size_t i = 0; i < repo_path.size(); i++) {
+ if (i != 0)
+ ret.push_back('_');
+ ret.append(base::IntToString(repo_path[i]));
+ }
+ ret += TargetIndexToLetter(target_index);
+ return ret;
+}
+
+std::string RepoPathToFullTargetName(const std::vector<int>& repo_path,
+ int target_index) {
+ std::string ret;
+ for (size_t i = 0; i < repo_path.size(); i++) {
+ ret.push_back('/');
+ ret.append(base::IntToString(repo_path[i]));
+ }
+
+ ret += ":" + RepoPathToTargetName(repo_path, target_index);
+ return ret;
+}
+
+void WriteLevel(const std::vector<int>& repo_path,
+ int spread,
+ int max_depth,
+ int targets_per_level,
+ int files_per_target) {
+ base::FilePath dirname = RepoPathToPathName(repo_path);
+ base::FilePath filename = dirname.AppendASCII("BUILD.gn");
+ std::cout << "Writing " << FilePathToUTF8(filename) << "\n";
+
+ // Don't keep the file open while recursing.
+ {
+ file_util::CreateDirectory(dirname);
+
+ std::ofstream file;
+ file.open(FilePathToUTF8(filename).c_str(),
+ std::ios_base::out | std::ios_base::binary);
+ files_written++;
+
+ for (int i = 0; i < targets_per_level; i++) {
+ targets_written++;
+ file << "executable(\"" << RepoPathToTargetName(repo_path, i)
+ << "\") {\n";
+ file << " sources = [\n";
+ for (int f = 0; f < files_per_target; f++)
+ file << " \"" << base::IntToString(f) << ".cc\",\n";
+
+ if (repo_path.size() < (size_t)max_depth) {
+ file << " ]\n";
+ file << " deps = [\n";
+ for (int d = 0; d < spread; d++) {
+ std::vector<int> cur = repo_path;
+ cur.push_back(d);
+ for (int t = 0; t < targets_per_level; t++)
+ file << " \"" << RepoPathToFullTargetName(cur, t) << "\",\n";
+ }
+ }
+ file << " ]\n}\n\n";
+ }
+ }
+ if (repo_path.size() < (size_t)max_depth) {
+ // Recursively generate subdirs.
+ for (int i = 0; i < spread; i++) {
+ std::vector<int> cur = repo_path;
+ cur.push_back(i);
+ WriteLevel(cur, spread, max_depth, targets_per_level, files_per_target);
+ }
+ }
+}
+
+int main() {
+ WriteLevel(std::vector<int>(), 5, 4, 3, 50); // 781 files, 2343 targets
+ //WriteLevel(std::vector<int>(), 6, 4, 2, 50);
+ std::cout << "Wrote " << files_written << " files and "
+ << targets_written << " targets.\n";
+ return 0;
+}
diff --git a/tools/gn/gn.gyp b/tools/gn/gn.gyp
new file mode 100644
index 0000000..4904e3d
--- /dev/null
+++ b/tools/gn/gn.gyp
@@ -0,0 +1,171 @@
+{
+ 'variables': {
+ 'chromium_code': 1,
+ },
+ 'targets': [
+ {
+ 'target_name': 'gn_lib',
+ 'type': 'static_library',
+ 'dependencies': [
+ '../../base/base.gyp:base',
+ ],
+ 'sources': [
+ 'build_settings.cc',
+ 'build_settings.h',
+ 'command_desc.cc',
+ 'command_desc.h',
+ 'command_gen.cc',
+ 'command_gen.h',
+ 'commands.h',
+ 'config.cc',
+ 'config.h',
+ 'config_values.cc',
+ 'config_values.h',
+ 'config_values_extractors.cc',
+ 'config_values_extractors.h',
+ 'config_values_generator.cc',
+ 'config_values_generator.h',
+ 'err.cc',
+ 'err.h',
+ 'escape.cc',
+ 'escape.h',
+ 'file_template.cc',
+ 'file_template.h',
+ 'filesystem_utils.cc',
+ 'filesystem_utils.h',
+ 'functions_target.cc',
+ 'functions.cc',
+ 'functions.h',
+ 'function_exec_script.cc',
+ 'function_process_file_template.cc',
+ 'function_read_file.cc',
+ 'function_set_default_toolchain.cc',
+ 'function_template.cc',
+ 'function_toolchain.cc',
+ 'function_write_file.cc',
+ 'import_manager.cc',
+ 'import_manager.h',
+ 'input_conversion.cc',
+ 'input_conversion.h',
+ 'input_file.cc',
+ 'input_file.h',
+ 'input_file_manager.cc',
+ 'input_file_manager.h',
+ 'item.cc',
+ 'item.h',
+ 'item_node.cc',
+ 'item_node.h',
+ 'item_tree.cc',
+ 'item_tree.h',
+ 'label.cc',
+ 'label.h',
+ 'location.h',
+ 'ninja_build_writer.cc',
+ 'ninja_build_writer.h',
+ 'ninja_helper.cc',
+ 'ninja_helper.h',
+ 'ninja_target_writer.cc',
+ 'ninja_target_writer.h',
+ 'ninja_toolchain_writer.cc',
+ 'ninja_toolchain_writer.h',
+ 'ninja_writer.cc',
+ 'ninja_writer.h',
+ 'operators.cc',
+ 'operators.h',
+ 'output_file.h',
+ 'parse_tree.cc',
+ 'parse_tree.h',
+ 'parser.cc',
+ 'parser.h',
+ 'path_output.cc',
+ 'path_output.h',
+ 'pattern.cc',
+ 'pattern.h',
+ 'scheduler.cc',
+ 'scheduler.h',
+ 'scope.cc',
+ 'scope.h',
+ 'scope_per_file_provider.cc',
+ 'scope_per_file_provider.h',
+ 'settings.cc',
+ 'settings.h',
+ 'setup.cc',
+ 'setup.h',
+ 'source_dir.cc',
+ 'source_dir.h',
+ 'source_file.cc',
+ 'source_file.h',
+ 'standard_out.cc',
+ 'standard_out.h',
+ 'string_utils.cc',
+ 'string_utils.h',
+ 'target.cc',
+ 'target.h',
+ 'target_generator.cc',
+ 'target_generator.h',
+ 'target_manager.cc',
+ 'target_manager.h',
+ 'token.cc',
+ 'token.h',
+ 'tokenizer.cc',
+ 'tokenizer.h',
+ 'toolchain.cc',
+ 'toolchain.h',
+ 'toolchain_manager.cc',
+ 'toolchain_manager.h',
+ 'value.cc',
+ 'value.h',
+ 'value_extractors.cc',
+ 'value_extractors.h',
+ ],
+ },
+ {
+ 'target_name': 'gn',
+ 'type': 'executable',
+ 'sources': [
+ 'gn_main.cc',
+ ],
+ 'dependencies': [
+ 'gn_lib',
+ '../../base/base.gyp:base',
+ '../../base/third_party/dynamic_annotations/dynamic_annotations.gyp:dynamic_annotations',
+ ],
+ },
+ {
+ 'target_name': 'gn_unittests',
+ 'type': '<(gtest_target_type)',
+ 'sources': [
+ 'escape_unittest.cc',
+ 'file_template_unittest.cc',
+ 'filesystem_utils_unittest.cc',
+ 'input_conversion_unittest.cc',
+ 'label_unittest.cc',
+ 'ninja_helper_unittest.cc',
+ 'parser_unittest.cc',
+ 'path_output_unittest.cc',
+ 'pattern_unittest.cc',
+ 'source_dir_unittest.cc',
+ 'string_utils_unittest.cc',
+ 'target_generator_unittest.cc',
+ 'target_manager_unittest.cc',
+ 'tokenizer_unittest.cc',
+ ],
+ 'dependencies': [
+ 'gn_lib',
+ '../../base/base.gyp:run_all_unittests',
+ '../../base/base.gyp:test_support_base',
+ '../../testing/gtest.gyp:gtest',
+ ],
+ },
+ {
+ 'target_name': 'generate_test_gn_data',
+ 'type': 'executable',
+ 'sources': [
+ 'generate_test_gn_data.cc',
+ ],
+ 'dependencies': [
+ '../../base/base.gyp:base',
+ ],
+ }
+ ],
+}
diff --git a/tools/gn/gn_main.cc b/tools/gn/gn_main.cc
new file mode 100644
index 0000000..6f5b31e
--- /dev/null
+++ b/tools/gn/gn_main.cc
@@ -0,0 +1,59 @@
+// 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 "base/at_exit.h"
+#include "base/command_line.h"
+#include "base/strings/utf_string_conversions.h"
+#include "tools/gn/commands.h"
+#include "tools/gn/err.h"
+#include "tools/gn/location.h"
+
+namespace {
+
+std::vector<std::string> GetArgs(const CommandLine& cmdline) {
+ CommandLine::StringVector in_args = cmdline.GetArgs();
+#if defined(OS_WIN)
+ std::vector<std::string> out_args;
+ for (size_t i = 0; i < in_args.size(); i++)
+ out_args.push_back(base::WideToUTF8(in_args[i]));
+ return out_args;
+#else
+ return in_args;
+#endif
+}
+
+} // namespace
+
+int main(int argc, char** argv) {
+ base::AtExitManager at_exit;
+ CommandLine::Init(argc, argv);
+
+ std::vector<std::string> args = GetArgs(*CommandLine::ForCurrentProcess());
+
+ std::string command;
+ if (args.empty()) {
+ command = "gen";
+ } else {
+ command = args[0];
+ args.erase(args.begin());
+ }
+
+ int retval = 0;
+ if (command == "gen") {
+ retval = RunGenCommand(args);
+ } else if (command == "desc" || command == "wtf") {
+ retval = RunDescCommand(args);
+ } else if (command == "deps") {
+ retval = RunDepsCommand(args);
+ } else if (command == "tree") {
+ retval = RunTreeCommand(args);
+ } else {
+ Err(Location(),
+ "Command \"" + command + "\" unknown.").PrintToStdout();
+ retval = 1;
+ }
+
+ exit(retval); // Don't free memory, it can be really slow!
+ return retval;
+}
diff --git a/tools/gn/import_manager.cc b/tools/gn/import_manager.cc
new file mode 100644
index 0000000..774f866
--- /dev/null
+++ b/tools/gn/import_manager.cc
@@ -0,0 +1,83 @@
+// 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/import_manager.h"
+
+#include "base/memory/scoped_ptr.h"
+#include "base/stl_util.h"
+#include "tools/gn/parse_tree.h"
+#include "tools/gn/scheduler.h"
+
+namespace {
+
+// Returns a newly-allocated scope on success, null on failure.
+Scope* UncachedImport(const Settings* settings,
+ const SourceFile& file,
+ const ParseNode* node_for_err,
+ Err* err) {
+ const ParseNode* node = g_scheduler->input_file_manager()->SyncLoadFile(
+ node_for_err->GetRange(), settings->build_settings(), file, err);
+ if (!node)
+ return NULL;
+ const BlockNode* block = node->AsBlock();
+ CHECK(block);
+
+ scoped_ptr<Scope> scope(new Scope(settings->base_config()));
+ scope->SetProcessingImport();
+ block->ExecuteBlockInScope(scope.get(), err);
+ if (err->has_error())
+ return NULL;
+ scope->ClearProcessingImport();
+
+ return scope.release();
+}
+
+} // namesapce
+
+ImportManager::ImportManager() {
+}
+
+ImportManager::~ImportManager() {
+ STLDeleteContainerPairSecondPointers(imports_.begin(), imports_.end());
+}
+
+bool ImportManager::DoImport(const SourceFile& file,
+ const ParseNode* node_for_err,
+ Scope* scope,
+ Err* err) {
+ // See if we have a cached import, but be careful to actually do the scope
+ // copying outside of the lock.
+ const Scope* imported_scope = NULL;
+ {
+ base::AutoLock lock(lock_);
+ ImportMap::const_iterator found = imports_.find(file);
+ if (found != imports_.end())
+ imported_scope = found->second;
+ }
+
+ if (!imported_scope) {
+ // Do a new import of the file.
+ imported_scope = UncachedImport(scope->settings(), file,
+ node_for_err, err);
+ if (!imported_scope)
+ return false;
+
+ // We loaded the file outside the lock. This means that there could be a
+ // race and the file was already loaded on a background thread. Recover
+ // from this and use the existing one if that happens.
+ {
+ base::AutoLock lock(lock_);
+ ImportMap::const_iterator found = imports_.find(file);
+ if (found != imports_.end()) {
+ delete imported_scope;
+ imported_scope = found->second;
+ } else {
+ imports_[file] = imported_scope;
+ }
+ }
+ }
+
+ return imported_scope->NonRecursiveMergeTo(scope, node_for_err,
+ "import", err);
+}
diff --git a/tools/gn/import_manager.h b/tools/gn/import_manager.h
new file mode 100644
index 0000000..725a5b2
--- /dev/null
+++ b/tools/gn/import_manager.h
@@ -0,0 +1,41 @@
+// 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_IMPORT_MANAGER_H_
+#define TOOLS_GN_IMPORT_MANAGER_H_
+
+#include <map>
+
+#include "base/synchronization/lock.h"
+
+class Err;
+class ParseNode;
+class Scope;
+class SourceFile;
+
+// Provides a cache of the results of importing scopes so the results can
+// be re-used rather than running the imported files multiple times.
+class ImportManager {
+ public:
+ ImportManager();
+ ~ImportManager();
+
+ // Does an import of the given file into the given scope. On error, sets the
+ // error and returns false.
+ bool DoImport(const SourceFile& file,
+ const ParseNode* node_for_err,
+ Scope* scope,
+ Err* err);
+
+ private:
+ base::Lock lock_;
+
+ // Owning pointers to the scopes.
+ typedef std::map<SourceFile, const Scope*> ImportMap;
+ ImportMap imports_;
+
+ DISALLOW_COPY_AND_ASSIGN(ImportManager);
+};
+
+#endif // TOOLS_GN_IMPORT_MANAGER_H_
diff --git a/tools/gn/input_conversion.cc b/tools/gn/input_conversion.cc
new file mode 100644
index 0000000..c0a0685
--- /dev/null
+++ b/tools/gn/input_conversion.cc
@@ -0,0 +1,205 @@
+// 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 "input_conversion.h"
+
+#include "base/strings/string_split.h"
+#include "base/strings/string_util.h"
+#include "tools/gn/build_settings.h"
+#include "tools/gn/err.h"
+#include "tools/gn/input_file.h"
+#include "tools/gn/label.h"
+#include "tools/gn/parse_tree.h"
+#include "tools/gn/parser.h"
+#include "tools/gn/scope.h"
+#include "tools/gn/settings.h"
+#include "tools/gn/tokenizer.h"
+#include "tools/gn/value.h"
+
+namespace {
+
+// Returns the "first bit" of some script output for writing to error messages.
+std::string GetExampleOfBadInput(const std::string& input) {
+ std::string result(input);
+
+ // Maybe the result starts with a blank line or something, which we don't
+ // want.
+ TrimWhitespaceASCII(result, TRIM_ALL, &result);
+
+ // Now take the first line, or the first set of chars, whichever is shorter.
+ bool trimmed = false;
+ size_t newline_offset = result.find('\n');
+ if (newline_offset != std::string::npos) {
+ trimmed = true;
+ result.resize(newline_offset);
+ }
+ TrimWhitespaceASCII(result, TRIM_ALL, &result);
+
+ const int kMaxSize = 50;
+ if (result.size() > kMaxSize) {
+ trimmed = true;
+ result.resize(kMaxSize);
+ }
+
+ if (trimmed)
+ result.append("...");
+ return result;
+}
+
+// When parsing the result as a value, we may get various types of errors.
+// This creates an error message for this case with an optional nested error
+// message to reference. If there is no nested err, pass Err().
+//
+// This code also takes care to rewrite the original error which will reference
+// the temporary InputFile which won't exist when the error is propogated
+// out to a higher level.
+Err MakeParseErr(const std::string& input,
+ const ParseNode* origin,
+ const Err& nested) {
+ std::string help_text =
+ "When parsing a result as a \"value\" it should look like a list:\n"
+ " [ \"a\", \"b\", 5 ]\n"
+ "or a single literal:\n"
+ " \"my result\"\n"
+ "but instead I got this, which I find very confusing:\n";
+ help_text.append(input);
+ if (nested.has_error())
+ help_text.append("\nThe exact error was:");
+
+ Err result(origin, "Script result wasn't a valid value.", help_text);
+ if (nested.has_error()) {
+ result.AppendSubErr(Err(LocationRange(), nested.message(),
+ nested.help_text()));
+ }
+ return result;
+}
+
+// Sets the origin of the value and any nested values with the given node.
+void RecursivelySetOrigin(Value* value, const ParseNode* origin) {
+ value->set_origin(origin);
+ if (value->type() == Value::LIST) {
+ std::vector<Value>& list_value = value->list_value();
+ for (size_t i = 0; i < list_value.size(); i++)
+ RecursivelySetOrigin(&list_value[i], origin);
+ }
+}
+
+Value ParseString(const std::string& input,
+ const ParseNode* origin,
+ Err* err) {
+ SourceFile empty_source_for_most_vexing_parse;
+ InputFile input_file(empty_source_for_most_vexing_parse);
+ input_file.SetContents(input);
+
+ std::vector<Token> tokens = Tokenizer::Tokenize(&input_file, err);
+ if (err->has_error()) {
+ *err = MakeParseErr(input, origin, *err);
+ return Value();
+ }
+
+ scoped_ptr<ParseNode> expression = Parser::ParseExpression(tokens, err);
+ if (err->has_error()) {
+ *err = MakeParseErr(input, origin, *err);
+ return Value();
+ }
+
+ // It's valid for the result to be a null pointer, this just means that the
+ // script returned nothing.
+ if (!expression)
+ return Value();
+
+ // The result should either be a list or a literal, anything else is
+ // invalid.
+ if (!expression->AsList() && !expression->AsLiteral()) {
+ *err = MakeParseErr(input, origin, Err());
+ return Value();
+ }
+
+ BuildSettings build_settings;
+ Label empty_label;
+ Toolchain toolchain(empty_label);
+ Settings settings(&build_settings, &toolchain, std::string());
+ Scope scope(&settings);
+
+ Err nested_err;
+ Value result = expression->Execute(&scope, &nested_err);
+ if (nested_err.has_error()) {
+ *err = MakeParseErr(input, origin, nested_err);
+ return Value();
+ }
+
+ // The returned value will have references to the temporary parse nodes we
+ // made on the stack. If the values are used in an error message in the
+ // future, this will crash. Reset the origin of all values to be our
+ // containing origin.
+ RecursivelySetOrigin(&result, origin);
+ return result;
+}
+
+Value ParseList(const std::string& input,
+ const ParseNode* origin,
+ Err* err) {
+ Value ret(origin, Value::LIST);
+ std::vector<std::string> as_lines;
+ base::SplitString(input, '\n', &as_lines);
+
+ // Trim empty lines from the end.
+ // Do we want to make this configurable?
+ while (!as_lines.empty() && as_lines[as_lines.size() - 1].empty())
+ as_lines.resize(as_lines.size() - 1);
+
+ ret.list_value().reserve(as_lines.size());
+ for (size_t i = 0; i < as_lines.size(); i++)
+ ret.list_value().push_back(Value(origin, as_lines[i]));
+ return ret;
+}
+
+} // namespace
+
+/*
+input_conversion: Specifies how to transform input to a variable.
+
+ input_conversion is an argument to read_file and exec_script that specifies
+ how the result of the read operation should be converted into a variable.
+
+ "list lines":
+ Return the file contents as a list, with a string for each line. The
+ newlines will not be present in the result. Empty newlines will be
+ trimmed from the trailing end of the returned list.
+
+ "value":
+ Parse the input as if it was a literal rvalue in a buildfile.
+ Examples of typical program output using this mode:
+ [ "foo", "bar" ] (result will be a list)
+ or
+ "foo bar" (result will be a string)
+ or
+ 5 (result will be an integer)
+
+ Note that if the input is empty, the result will be a null value which
+ will produce an error if assigned to a variable.
+
+ "string":
+ Return the file contents into a single string.
+*/
+
+Value ConvertInputToValue(const std::string& input,
+ const ParseNode* origin,
+ const Value& input_conversion_value,
+ Err* err) {
+ if (!input_conversion_value.VerifyTypeIs(Value::STRING, err))
+ return Value();
+ const std::string& input_conversion = input_conversion_value.string_value();
+
+ if (input_conversion == "value")
+ return ParseString(input, origin, err);
+ if (input_conversion == "string")
+ return Value(origin, input);
+ if (input_conversion == "list lines")
+ return ParseList(input, origin, err);
+
+ *err = Err(input_conversion_value, "Not a valid read file mode.",
+ "Have you considered a career in retail?");
+ return Value();
+}
diff --git a/tools/gn/input_conversion.h b/tools/gn/input_conversion.h
new file mode 100644
index 0000000..d15e513
--- /dev/null
+++ b/tools/gn/input_conversion.h
@@ -0,0 +1,26 @@
+// 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_INPUT_CONVERSION_H_
+#define TOOLS_GN_INPUT_CONVERSION_H_
+
+#include <string>
+
+class Err;
+class ParseNode;
+class Value;
+
+// Converts the given input string (is read from a file or output from a
+// script) to a Value. Conversions as specified in the input_conversion string
+// will be performed. The given origin will be used for constructing the
+// resulting Value.
+//
+// If the conversion string is invalid, the error will be set and an empty
+// value will be returned.
+Value ConvertInputToValue(const std::string& input,
+ const ParseNode* origin,
+ const Value& input_conversion_value,
+ Err* err);
+
+#endif // TOOLS_GN_INPUT_CONVERSION_H_
diff --git a/tools/gn/input_conversion_unittest.cc b/tools/gn/input_conversion_unittest.cc
new file mode 100644
index 0000000..59c0123
--- /dev/null
+++ b/tools/gn/input_conversion_unittest.cc
@@ -0,0 +1,81 @@
+// 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/err.h"
+#include "tools/gn/input_conversion.h"
+#include "tools/gn/value.h"
+
+TEST(InputConversion, String) {
+ Err err;
+ std::string input("\nfoo bar \n");
+ Value result = ConvertInputToValue(input, NULL, Value(NULL, "string"), &err);
+ EXPECT_FALSE(err.has_error());
+ EXPECT_EQ(Value::STRING, result.type());
+ EXPECT_EQ(input, result.string_value());
+}
+
+TEST(InputConversion, ListLines) {
+ Err err;
+ std::string input("\nfoo\nbar \n");
+ Value result = ConvertInputToValue(input, NULL, Value(NULL, "list lines"),
+ &err);
+ EXPECT_FALSE(err.has_error());
+ EXPECT_EQ(Value::LIST, result.type());
+ ASSERT_EQ(3u, result.list_value().size());
+ EXPECT_EQ("", result.list_value()[0].string_value());
+ EXPECT_EQ("foo", result.list_value()[1].string_value());
+ EXPECT_EQ("bar", result.list_value()[2].string_value());
+}
+
+TEST(InputConversion, ValueString) {
+ Err err;
+ std::string input("\"str\"");
+ Value result = ConvertInputToValue(input, NULL, Value(NULL, "value"), &err);
+ EXPECT_FALSE(err.has_error());
+ EXPECT_EQ(Value::STRING, result.type());
+ EXPECT_EQ("str", result.string_value());
+}
+
+TEST(InputConversion, ValueInt) {
+ Err err;
+ std::string input("\n\n 6 \n ");
+ Value result = ConvertInputToValue(input, NULL, Value(NULL, "value"), &err);
+ EXPECT_FALSE(err.has_error());
+ EXPECT_EQ(Value::INTEGER, result.type());
+ EXPECT_EQ(6, result.int_value());
+}
+
+TEST(InputConversion, ValueList) {
+ Err err;
+ std::string input("\n [ \"a\", 5]");
+ Value result = ConvertInputToValue(input, NULL, Value(NULL, "value"), &err);
+ EXPECT_FALSE(err.has_error());
+ ASSERT_EQ(Value::LIST, result.type());
+ ASSERT_EQ(2u, result.list_value().size());
+ EXPECT_EQ("a", result.list_value()[0].string_value());
+ EXPECT_EQ(5, result.list_value()[1].int_value());
+}
+
+TEST(InputConversion, ValueEmpty) {
+ Err err;
+ ConvertInputToValue("", NULL, Value(NULL, "value"), &err);
+}
+
+TEST(InputConversion, ValueError) {
+ Err err;
+ std::string input("\n [ \"a\", 5\nfoo bar");
+ Value result = ConvertInputToValue(input, NULL, Value(NULL, "value"), &err);
+ EXPECT_TRUE(err.has_error());
+
+ // Blocks not allowed.
+ input = "{ foo = 5 }";
+ result = ConvertInputToValue(input, NULL, Value(NULL, "value"), &err);
+ EXPECT_TRUE(err.has_error());
+
+ // Function calls not allowed.
+ input = "print(5)";
+ result = ConvertInputToValue(input, NULL, Value(NULL, "value"), &err);
+ EXPECT_TRUE(err.has_error());
+}
diff --git a/tools/gn/input_file.cc b/tools/gn/input_file.cc
new file mode 100644
index 0000000..b2c3c0b
--- /dev/null
+++ b/tools/gn/input_file.cc
@@ -0,0 +1,30 @@
+// 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/input_file.h"
+
+#include "base/file_util.h"
+
+InputFile::InputFile(const SourceFile& name)
+ : name_(name),
+ dir_(name_.GetDir()),
+ contents_loaded_(false) {
+}
+
+InputFile::~InputFile() {
+}
+
+void InputFile::SetContents(const std::string& c) {
+ contents_loaded_ = true;
+ contents_ = c;
+}
+
+bool InputFile::Load(const base::FilePath& system_path) {
+ if (file_util::ReadFileToString(system_path, &contents_)) {
+ contents_loaded_ = true;
+ return true;
+ }
+ return false;
+}
+
diff --git a/tools/gn/input_file.h b/tools/gn/input_file.h
new file mode 100644
index 0000000..66cf55c
--- /dev/null
+++ b/tools/gn/input_file.h
@@ -0,0 +1,52 @@
+// 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_INPUT_FILE_H_
+#define TOOLS_GN_INPUT_FILE_H_
+
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/files/file_path.h"
+#include "base/logging.h"
+#include "tools/gn/source_dir.h"
+#include "tools/gn/source_file.h"
+
+class InputFile {
+ public:
+ InputFile(const SourceFile& name);
+
+ // Constructor for testing. Uses an empty file path and a given contents.
+ //InputFile(const char* contents);
+ ~InputFile();
+
+ const SourceFile& name() const { return name_; }
+
+ // The directory is just a cached version of name_->GetDir() but we get this
+ // a lot so computing it once up front saves a bunch of work.
+ const SourceDir& dir() const { return dir_; }
+
+ const std::string& contents() const {
+ DCHECK(contents_loaded_);
+ return contents_;
+ }
+
+ // For testing and in cases where this input doesn't actually refer to
+ // "a file".
+ void SetContents(const std::string& c);
+
+ // Loads the given file synchronously, returning true on success. This
+ bool Load(const base::FilePath& system_path);
+
+ private:
+ SourceFile name_;
+ SourceDir dir_;
+
+ bool contents_loaded_;
+ std::string contents_;
+
+ DISALLOW_COPY_AND_ASSIGN(InputFile);
+};
+
+#endif // TOOLS_GN_INPUT_FILE_H_
diff --git a/tools/gn/input_file_manager.cc b/tools/gn/input_file_manager.cc
new file mode 100644
index 0000000..e840ba0
--- /dev/null
+++ b/tools/gn/input_file_manager.cc
@@ -0,0 +1,254 @@
+// 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/input_file_manager.h"
+
+#include "base/bind.h"
+#include "base/stl_util.h"
+#include "tools/gn/filesystem_utils.h"
+#include "tools/gn/parser.h"
+#include "tools/gn/scheduler.h"
+#include "tools/gn/scope_per_file_provider.h"
+#include "tools/gn/tokenizer.h"
+
+namespace {
+
+void InvokeFileLoadCallback(const InputFileManager::FileLoadCallback& cb,
+ const ParseNode* node) {
+ cb.Run(node);
+}
+
+} // namespace
+
+InputFileManager::InputFileData::InputFileData(const SourceFile& file_name)
+ : file(file_name),
+ loaded(false),
+ sync_invocation(false) {
+}
+
+InputFileManager::InputFileData::~InputFileData() {
+}
+
+InputFileManager::InputFileManager() {
+}
+
+InputFileManager::~InputFileManager() {
+ // Should be single-threaded by now.
+ STLDeleteContainerPairSecondPointers(input_files_.begin(),
+ input_files_.end());
+}
+
+bool InputFileManager::AsyncLoadFile(const LocationRange& origin,
+ const BuildSettings* build_settings,
+ const SourceFile& file_name,
+ const FileLoadCallback& callback,
+ Err* err) {
+ // Try not to schedule callbacks while holding the lock. All cases that don't
+ // want to schedule should return early. Otherwise, this will be scheduled
+ // after we leave the lock.
+ base::Closure schedule_this;
+ {
+ base::AutoLock lock(lock_);
+
+ InputFileMap::const_iterator found = input_files_.find(file_name);
+ if (found == input_files_.end()) {
+ // New file, schedule load.
+ InputFileData* data = new InputFileData(file_name);
+ data->scheduled_callbacks.push_back(callback);
+ input_files_[file_name] = data;
+
+ schedule_this = base::Bind(&InputFileManager::BackgroundLoadFile,
+ this,
+ origin,
+ build_settings,
+ file_name,
+ &data->file);
+ } else {
+ InputFileData* data = found->second;
+
+ // Prevent mixing async and sync loads. See SyncLoadFile for discussion.
+ if (data->sync_invocation) {
+ g_scheduler->FailWithError(Err(
+ origin, "Load type mismatch.",
+ "The file \"" + file_name.value() + "\" was previously loaded\n"
+ "synchronously (via an import) and now you're trying to load it "
+ "asynchronously\n(via a deps rule). This is a class 2 misdemeanor: "
+ "a single input file must\nbe loaded the same way each time to "
+ "avoid blowing my tiny, tiny mind."));
+ return false;
+ }
+
+ if (data->loaded) {
+ // Can just directly issue the callback on the background thread.
+ schedule_this = base::Bind(&InvokeFileLoadCallback, callback,
+ data->parsed_root.get());
+ } else {
+ // Load is pending on this file, schedule the invoke.
+ data->scheduled_callbacks.push_back(callback);
+ return true;
+ }
+ }
+ }
+ g_scheduler->pool()->PostWorkerTaskWithShutdownBehavior(
+ FROM_HERE, schedule_this,
+ base::SequencedWorkerPool::BLOCK_SHUTDOWN);
+ return true;
+}
+
+const ParseNode* InputFileManager::SyncLoadFile(
+ const LocationRange& origin,
+ const BuildSettings* build_settings,
+ const SourceFile& file_name,
+ Err* err) {
+ base::AutoLock lock(lock_);
+
+ InputFileData* data = NULL;
+ InputFileMap::iterator found = input_files_.find(file_name);
+ if (found == input_files_.end()) {
+ base::AutoUnlock unlock(lock_);
+
+ // Haven't seen this file yet, start loading right now.
+ data = new InputFileData(file_name);
+ data->sync_invocation = true;
+ input_files_[file_name] = data;
+
+ if (!LoadFile(origin, build_settings, file_name, &data->file, err))
+ return NULL;
+ } else {
+ // This file has either been loaded or is pending loading.
+ data = found->second;
+
+ if (!data->sync_invocation) {
+ // Don't allow mixing of sync and async loads. If an async load is
+ // scheduled and then a bunch of threads need to load it synchronously
+ // and block on it loading, it could deadlock or at least cause a lot
+ // of wasted CPU while those threads wait for the load to complete (which
+ // may be far back in the input queue).
+ //
+ // We could work around this by promoting the load to a sync load. This
+ // requires a bunch of extra code to either check flags and likely do
+ // extra locking (bad) or to just do both types of load on the file and
+ // deal with the race condition.
+ //
+ // I have no practical way to test this, and generally we should have
+ // all include files processed synchronously and all build files
+ // processed asynchronously, so it doesn't happen in practice.
+ *err = Err(
+ origin, "Load type mismatch.",
+ "The file \"" + file_name.value() + "\" was previously loaded\n"
+ "asynchronously (via a deps rule) and now you're trying to load it "
+ "synchronously.\nThis is a class 2 misdemeanor: a single input file "
+ "must be loaded the same way\neach time to avoid blowing my tiny, "
+ "tiny mind.");
+ return NULL;
+ }
+
+ if (!data->loaded) {
+ // Wait for the already-pending sync load to complete.
+ if (!data->completion_event)
+ data->completion_event.reset(new base::WaitableEvent(false, false));
+ {
+ base::AutoUnlock unlock(lock_);
+ data->completion_event->Wait();
+ }
+ }
+ }
+
+ // The other load could have failed. In this case that error will be printed
+ // to the console, but we need to return something here, so make up a
+ // dummy error.
+ if (!data->parsed_root)
+ *err = Err(origin, "File parse failed");
+ return data->parsed_root.get();
+}
+
+int InputFileManager::GetInputFileCount() const {
+ base::AutoLock lock(lock_);
+ return input_files_.size();
+}
+
+void InputFileManager::GetAllInputFileNames(
+ std::vector<SourceFile>* result) const {
+ base::AutoLock lock(lock_);
+ result->reserve(input_files_.size());
+ for (InputFileMap::const_iterator i = input_files_.begin();
+ i != input_files_.end(); ++i) {
+ result->push_back(i->second->file.name());
+ }
+}
+
+void InputFileManager::BackgroundLoadFile(const LocationRange& origin,
+ const BuildSettings* build_settings,
+ const SourceFile& name,
+ InputFile* file) {
+ Err err;
+ if (!LoadFile(origin, build_settings, name, file, &err))
+ g_scheduler->FailWithError(err);
+}
+
+bool InputFileManager::LoadFile(const LocationRange& origin,
+ const BuildSettings* build_settings,
+ const SourceFile& name,
+ InputFile* file,
+ Err* err) {
+ // Do all of this stuff outside the lock. We should not give out file
+ // pointers until the read is complete.
+ if (g_scheduler->verbose_logging())
+ g_scheduler->Log("Loading", name.value());
+
+ // Read.
+ base::FilePath primary_path = build_settings->GetFullPath(name);
+ if (!file->Load(primary_path)) {
+ if (!build_settings->secondary_source_path().empty()) {
+ // Fall back to secondary source tree.
+ base::FilePath secondary_path =
+ build_settings->GetFullPathSecondary(name);
+ if (!file->Load(secondary_path)) {
+ *err = Err(origin, "Can't load input file.",
+ "Unable to load either \n" +
+ FilePathToUTF8(primary_path) + " or \n" +
+ FilePathToUTF8(secondary_path));
+ return false;
+ }
+ } else {
+ *err = Err(origin,
+ "Unable to load \"" + FilePathToUTF8(primary_path) + "\".");
+ return false;
+ }
+ }
+
+ if (g_scheduler->verbose_logging())
+ g_scheduler->Log("Parsing", name.value());
+
+ // Tokenize.
+ std::vector<Token> tokens = Tokenizer::Tokenize(file, err);
+ if (err->has_error())
+ return false;
+
+ // Parse.
+ scoped_ptr<ParseNode> root = Parser::Parse(tokens, err);
+ if (err->has_error())
+ return false;
+ ParseNode* unowned_root = root.get();
+
+ std::vector<FileLoadCallback> callbacks;
+ {
+ base::AutoLock lock(lock_);
+ DCHECK(input_files_.find(name) != input_files_.end());
+
+ InputFileData* data = input_files_[name];
+ data->loaded = true;
+ data->tokens.swap(tokens);
+ data->parsed_root = root.Pass();
+
+ callbacks.swap(data->scheduled_callbacks);
+ }
+
+ // Run pending invocations. Theoretically we could schedule each of these
+ // separately to get some parallelism. But normally there will only be one
+ // item in the list, so that's extra overhead and complexity for no gain.
+ for (size_t i = 0; i < callbacks.size(); i++)
+ callbacks[i].Run(unowned_root);
+ return true;
+}
diff --git a/tools/gn/input_file_manager.h b/tools/gn/input_file_manager.h
new file mode 100644
index 0000000..0f708d5
--- /dev/null
+++ b/tools/gn/input_file_manager.h
@@ -0,0 +1,123 @@
+// 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_INPUT_FILE_MANAGER_H_
+#define TOOLS_GN_INPUT_FILE_MANAGER_H_
+
+#include <set>
+#include <utility>
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/callback.h"
+#include "base/containers/hash_tables.h"
+#include "base/files/file_path.h"
+#include "base/memory/ref_counted.h"
+#include "base/synchronization/lock.h"
+#include "base/synchronization/waitable_event.h"
+#include "tools/gn/build_settings.h"
+#include "tools/gn/input_file.h"
+#include "tools/gn/parse_tree.h"
+#include "tools/gn/settings.h"
+
+class Err;
+class LocationRange;
+class ParseNode;
+class Token;
+
+// Manages loading and parsing files from disk. This doesn't actually have
+// any context for executing the results, so potentially multiple configs
+// could use the same input file (saving parsing).
+//
+// This class is threadsafe.
+//
+// InputFile objects must never be deleted while the program is running since
+// various state points into them.
+class InputFileManager : public base::RefCountedThreadSafe<InputFileManager> {
+ public:
+ // Callback issued when a file is laoded. On auccess, the parse node will
+ // refer to the root block of the file. On failure, this will be NULL.
+ typedef base::Callback<void(const ParseNode*)> FileLoadCallback;
+
+ InputFileManager();
+
+ // Loads the given file and executes the callback on the worker pool.
+ //
+ // There are two types of errors. For errors known synchronously, the error
+ // will be set, it will return false, and no work will be scheduled.
+ //
+ // For parse errors and such that happen in the future, the error will be
+ // logged to the scheduler and the callback will be invoked with a null
+ // ParseNode pointer. The given |origin| will be blamed for the invocation.
+ bool AsyncLoadFile(const LocationRange& origin,
+ const BuildSettings* build_settings,
+ const SourceFile& file_name,
+ const FileLoadCallback& callback,
+ Err* err);
+
+ // Loads and parses the given file synchronously, returning the root block
+ // corresponding to the parsed result. On error, return NULL and the given
+ // Err is set.
+ const ParseNode* SyncLoadFile(const LocationRange& origin,
+ const BuildSettings* build_settings,
+ const SourceFile& file_name,
+ Err* err);
+
+ int GetInputFileCount() const;
+
+ void GetAllInputFileNames(std::vector<SourceFile>* result) const;
+
+ private:
+ friend class base::RefCountedThreadSafe<InputFileManager>;
+
+ struct InputFileData {
+ InputFileData(const SourceFile& file_name);
+ ~InputFileData();
+
+ // Don't touch this outside the lock until it's marked loaded.
+ InputFile file;
+
+ bool loaded;
+
+ bool sync_invocation;
+
+ // Lists all invocations that need to be executed when the file completes
+ // loading.
+ std::vector<FileLoadCallback> scheduled_callbacks;
+
+ // Event to signal when the load is complete (or fails). This is lazily
+ // created only when a thread is synchronously waiting for this load (which
+ // only happens for imports).
+ scoped_ptr<base::WaitableEvent> completion_event;
+
+ std::vector<Token> tokens;
+
+ // Null before the file is loaded or if loading failed.
+ scoped_ptr<ParseNode> parsed_root;
+ };
+
+ virtual ~InputFileManager();
+
+ void BackgroundLoadFile(const LocationRange& origin,
+ const BuildSettings* build_settings,
+ const SourceFile& name,
+ InputFile* file);
+
+ // Loads the given file. On error, sets the Err and return false.
+ bool LoadFile(const LocationRange& origin,
+ const BuildSettings* build_settings,
+ const SourceFile& name,
+ InputFile* file,
+ Err* err);
+
+ mutable base::Lock lock_;
+
+ // Maps repo-relative filenames to the corresponding owned pointer.
+ typedef base::hash_map<SourceFile, InputFileData*> InputFileMap;
+ InputFileMap input_files_;
+
+ DISALLOW_COPY_AND_ASSIGN(InputFileManager);
+};
+
+#endif // TOOLS_GN_INPUT_FILE_MANAGER_H_
diff --git a/tools/gn/item.cc b/tools/gn/item.cc
new file mode 100644
index 0000000..747183c
--- /dev/null
+++ b/tools/gn/item.cc
@@ -0,0 +1,31 @@
+// 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/item.h"
+
+#include "base/logging.h"
+
+Item::Item(const Label& label) : label_(label) {
+}
+
+Item::~Item() {
+}
+
+Config* Item::AsConfig() { return NULL; }
+const Config* Item::AsConfig() const { return NULL; }
+Target* Item::AsTarget() { return NULL; }
+const Target* Item::AsTarget() const { return NULL; }
+Toolchain* Item::AsToolchain() { return NULL; }
+const Toolchain* Item::AsToolchain() const { return NULL; }
+
+std::string Item::GetItemTypeName() const {
+ if (AsConfig())
+ return "config";
+ if (AsTarget())
+ return "target";
+ if (AsToolchain())
+ return "toolchain";
+ NOTREACHED();
+ return "this thing that I have no idea what it is";
+}
diff --git a/tools/gn/item.h b/tools/gn/item.h
new file mode 100644
index 0000000..aa71544
--- /dev/null
+++ b/tools/gn/item.h
@@ -0,0 +1,45 @@
+// 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_ITEM_H_
+#define TOOLS_GN_ITEM_H_
+
+#include <string>
+
+#include "tools/gn/label.h"
+
+class Config;
+class Target;
+class Toolchain;
+
+// A named item (target, config, etc.) that participates in the dependency
+// graph.
+class Item {
+ public:
+ Item(const Label& label);
+ virtual ~Item();
+
+ const Label& label() const { return label_; }
+
+ // Manual RTTI.
+ virtual Config* AsConfig();
+ virtual const Config* AsConfig() const;
+ virtual Target* AsTarget();
+ virtual const Target* AsTarget() const;
+ virtual Toolchain* AsToolchain();
+ virtual const Toolchain* AsToolchain() const;
+
+ // Returns a name like "target" or "config" for the type of item this is, to
+ // be used in logging and error messages.
+ std::string GetItemTypeName() const;
+
+ // Called when this item is resolved, meaning it and all of its dependents
+ // have no unresolved deps.
+ virtual void OnResolved() {}
+
+ private:
+ Label label_;
+};
+
+#endif // TOOLS_GN_ITEM_H_
diff --git a/tools/gn/item_node.cc b/tools/gn/item_node.cc
new file mode 100644
index 0000000..776a126
--- /dev/null
+++ b/tools/gn/item_node.cc
@@ -0,0 +1,51 @@
+// 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/item_node.h"
+
+#include <algorithm>
+
+#include "base/callback.h"
+#include "base/logging.h"
+#include "tools/gn/item.h"
+
+ItemNode::ItemNode(Item* i)
+ : state_(REFERENCED),
+ item_(i) {
+}
+
+ItemNode::~ItemNode() {
+}
+
+void ItemNode::AddDependency(ItemNode* node) {
+ if (direct_dependencies_.find(node) != direct_dependencies_.end())
+ return; // Already have this dep.
+ direct_dependencies_.insert(node);
+
+ if (node->state() != RESOLVED) {
+ // Wire up the pending resolution info.
+ unresolved_dependencies_.insert(node);
+ node->waiting_on_resolution_.insert(this);
+ }
+}
+
+void ItemNode::MarkDirectDependencyResolved(ItemNode* node) {
+ DCHECK(unresolved_dependencies_.find(node) != unresolved_dependencies_.end());
+ unresolved_dependencies_.erase(node);
+}
+
+void ItemNode::SwapOutWaitingDependencySet(ItemNodeSet* out_set) {
+ waiting_on_resolution_.swap(*out_set);
+}
+
+void ItemNode::SetGenerated() {
+ state_ = GENERATED;
+}
+
+void ItemNode::SetResolved() {
+ state_ = RESOLVED;
+
+ if (!resolved_closure_.is_null())
+ resolved_closure_.Run();
+}
diff --git a/tools/gn/item_node.h b/tools/gn/item_node.h
new file mode 100644
index 0000000..297010f
--- /dev/null
+++ b/tools/gn/item_node.h
@@ -0,0 +1,119 @@
+// 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_ITEM_NODE_H_
+#define TOOLS_GN_ITEM_NODE_H_
+
+#include <set>
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/callback.h"
+#include "base/memory/scoped_ptr.h"
+#include "tools/gn/location.h"
+
+class Item;
+
+// Represents a node in the depdency tree. It references an Item which is
+// the actual thing.
+//
+// The items and nodes are split apart so that the ItemTree can manipulate
+// the dependencies one one thread while the Item itself is been modified on
+// another.
+class ItemNode {
+ public:
+ enum State {
+ // Another item has referenced this one by name, but we have not yet
+ // encountered this item to know what it is.
+ REFERENCED,
+
+ // This item has been defined but some of the dependencies it references
+ // have not been.
+ GENERATED,
+
+ // All of this item's transitive dependencies have been found and
+ // resolved.
+ RESOLVED,
+ };
+
+ typedef std::set<ItemNode*> ItemNodeSet;
+
+ // Takes ownership of the pointer.
+ // Initial state will be REFERENCED.
+ ItemNode(Item* i);
+ ~ItemNode();
+
+ State state() const { return state_; }
+
+ // This closure will be executed when the item is resolved.
+ void set_resolved_closure(const base::Closure& closure) {
+ resolved_closure_ = closure;
+ }
+
+ const Item* item() const { return item_.get(); }
+ Item* item() { return item_.get(); }
+
+ // Where this was created from, which might be when it was generated or
+ // when it was first referenced from another target.
+ const LocationRange& originally_referenced_from_here() const {
+ return originally_referenced_from_here_;
+ }
+ void set_originally_referenced_from_here(const LocationRange& r) {
+ originally_referenced_from_here_ = r;
+ }
+
+ // Where this was generated from. This will be empty for items that have
+ // been referenced but not generated. Note that this has to be one the
+ // ItemNode because it can be changing from multiple threads and we need
+ // to be sure that access is serialized.
+ const LocationRange& generated_from_here() const {
+ return generated_from_here_;
+ }
+ void set_generated_from_here(const LocationRange& r) {
+ generated_from_here_ = r;
+ }
+
+ const ItemNodeSet& direct_dependencies() const {
+ return direct_dependencies_;
+ }
+ const ItemNodeSet& unresolved_dependencies() const {
+ return unresolved_dependencies_;
+ }
+
+ void AddDependency(ItemNode* node);
+
+ // Removes the given dependency from the unresolved list. Does not do
+ // anything else to update waiters.
+ void MarkDirectDependencyResolved(ItemNode* node);
+
+ // Destructively retrieve the set of waiting nodes.
+ void SwapOutWaitingDependencySet(ItemNodeSet* out_set);
+
+ void SetGenerated();
+ void SetResolved();
+
+ private:
+ State state_;
+ scoped_ptr<Item> item_;
+
+ LocationRange originally_referenced_from_here_;
+ LocationRange generated_from_here_;
+
+ // What to run when this item is resolved.
+ base::Closure resolved_closure_;
+
+ // Everything this item directly depends on.
+ ItemNodeSet direct_dependencies_;
+
+ // Unresolved things this item directly depends on.
+ ItemNodeSet unresolved_dependencies_;
+
+ // These items are waiting on us to be resolved before they can be
+ // resolved. This is the backpointer for unresolved_dependencies_.
+ ItemNodeSet waiting_on_resolution_;
+
+ DISALLOW_COPY_AND_ASSIGN(ItemNode);
+};
+
+#endif // TOOLS_GN_ITEM_NODE_H_
diff --git a/tools/gn/item_tree.cc b/tools/gn/item_tree.cc
new file mode 100644
index 0000000..a4d1181
--- /dev/null
+++ b/tools/gn/item_tree.cc
@@ -0,0 +1,193 @@
+// 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/item_tree.h"
+
+#include <algorithm>
+
+#include "base/stl_util.h"
+#include "tools/gn/err.h"
+#include "tools/gn/item.h"
+#include "tools/gn/item_node.h"
+
+namespace {
+
+// Recursively looks in the tree for a given node, returning true if it
+// was found in the dependecy graph. This is used to see if a given node
+// participates in a cycle.
+//
+// Note that "look_for" and "search_in" will be the same node when starting the
+// search, so we don't want to return true in that case.
+//
+// If a cycle is found, the return value will be true and the cycle vector will
+// be filled with the path (in reverse order).
+bool RecursiveFindCycle(const ItemNode* look_for,
+ const ItemNode* search_in,
+ std::vector<const ItemNode*>* cycle) {
+ const ItemNode::ItemNodeSet& unresolved =
+ search_in->unresolved_dependencies();
+ for (ItemNode::ItemNodeSet::const_iterator i = unresolved.begin();
+ i != unresolved.end(); ++i) {
+ if (*i == look_for) {
+ cycle->push_back(*i);
+ return true;
+ }
+
+ if (RecursiveFindCycle(look_for, *i, cycle)) {
+ // Found a cycle inside this one, record our path and return.
+ cycle->push_back(*i);
+ return true;
+ }
+ }
+ return false;
+}
+
+} // namespace
+
+ItemTree::ItemTree() {
+}
+
+ItemTree::~ItemTree() {
+ STLDeleteContainerPairSecondPointers(items_.begin(), items_.end());
+}
+
+ItemNode* ItemTree::GetExistingNodeLocked(const Label& label) {
+ lock_.AssertAcquired();
+ StringToNodeHash::iterator found = items_.find(label);
+ if (found == items_.end())
+ return NULL;
+ return found->second;
+}
+
+void ItemTree::AddNodeLocked(ItemNode* node) {
+ lock_.AssertAcquired();
+ DCHECK(items_.find(node->item()->label()) == items_.end());
+ items_[node->item()->label()] = node;
+}
+
+Err ItemTree::MarkItemGeneratedLocked(const Label& label) {
+ lock_.AssertAcquired();
+ DCHECK(items_.find(label) != items_.end());
+
+ ItemNode* node = items_[label];
+
+ if (!node->unresolved_dependencies().empty()) {
+ // Still some pending dependencies, wait for those to be resolved.
+ node->SetGenerated();
+ return Err();
+ }
+ return MarkItemResolvedLocked(node);
+}
+
+void ItemTree::GetAllItemsLocked(std::vector<const Item*>* dest) const {
+ lock_.AssertAcquired();
+ dest->reserve(items_.size());
+ for (StringToNodeHash::const_iterator i = items_.begin();
+ i != items_.end(); ++i) {
+ dest->push_back(i->second->item());
+ }
+}
+
+Err ItemTree::CheckForBadItems() const {
+ base::AutoLock lock(lock_);
+
+ // Look for errors where we find a GENERATED node that refers to a REFERENCED
+ // one. There may be other nodes depending on the GENERATED one, but listing
+ // all of those isn't helpful, we want to find the broken link.
+ //
+ // This finds normal "missing dependency" errors but does not find circular
+ // dependencies because in this case all items in the cycle will be GENERATED
+ // but none will be resolved. If this happens, we'll check explicitly for
+ // that below.
+ std::vector<const ItemNode*> bad_nodes;
+ std::string depstring;
+ for (StringToNodeHash::const_iterator i = items_.begin();
+ i != items_.end(); ++i) {
+ const ItemNode* src = i->second;
+
+ if (src->state() == ItemNode::GENERATED) {
+ bad_nodes.push_back(src);
+
+ // Check dependencies.
+ for (ItemNode::ItemNodeSet::const_iterator dest =
+ src->unresolved_dependencies().begin();
+ dest != src->unresolved_dependencies().end();
+ ++dest) {
+ if ((*dest)->state() == ItemNode::REFERENCED) {
+ depstring += "\"" + src->item()->label().GetUserVisibleName(false) +
+ "\" needs " + (*dest)->item()->GetItemTypeName() +
+ " \"" + (*dest)->item()->label().GetUserVisibleName(false) +
+ "\"\n";
+ }
+ }
+ }
+ }
+
+ if (!bad_nodes.empty() && depstring.empty()) {
+ // Our logic above found a bad node but didn't identify the problem. This
+ // normally means a circular dependency.
+ depstring = CheckForCircularDependenciesLocked(bad_nodes);
+ if (depstring.empty()) {
+ // Something's very wrong, just dump out the bad nodes.
+ depstring = "I have no idea what went wrong, but these are unresolved, "
+ "possible due to an\ninternal error:";
+ for (size_t i = 0; i < bad_nodes.size(); i++) {
+ depstring += "\n\"" +
+ bad_nodes[i]->item()->label().GetUserVisibleName(false) + "\"";
+ }
+ }
+ }
+
+ if (depstring.empty())
+ return Err();
+ return Err(Location(), "Unresolved dependencies.", depstring);
+}
+
+Err ItemTree::MarkItemResolvedLocked(ItemNode* node) {
+ node->SetResolved();
+ node->item()->OnResolved();
+
+ // Now update our waiters, pushing the "resolved" bit.
+ ItemNode::ItemNodeSet waiting;
+ node->SwapOutWaitingDependencySet(&waiting);
+ for (ItemNode::ItemNodeSet::iterator i = waiting.begin();
+ i != waiting.end(); ++i) {
+ ItemNode* waiter = *i;
+
+ // Our node should be unresolved in the waiter.
+ DCHECK(waiter->unresolved_dependencies().find(node) !=
+ waiter->unresolved_dependencies().end());
+ waiter->MarkDirectDependencyResolved(node);
+
+ // Recursively mark nodes as resolved.
+ if (waiter->state() == ItemNode::GENERATED &&
+ waiter->unresolved_dependencies().empty()) {
+ Err err = MarkItemResolvedLocked(waiter);
+ if (err.has_error())
+ return err;
+ }
+ }
+
+ return Err();
+}
+
+std::string ItemTree::CheckForCircularDependenciesLocked(
+ const std::vector<const ItemNode*>& bad_nodes) const {
+ std::vector<const ItemNode*> cycle;
+ if (!RecursiveFindCycle(bad_nodes[0], bad_nodes[0], &cycle))
+ return std::string(); // Didn't find a cycle, something else is wrong.
+
+ cycle.push_back(bad_nodes[0]);
+ std::string ret = "There is a dependency cycle:";
+
+ // Walk backwards since the dependency arrows point in the reverse direction.
+ for (int i = static_cast<int>(cycle.size()) - 1; i >= 0; i--) {
+ ret += "\n \"" + cycle[i]->item()->label().GetUserVisibleName(false) +
+ "\"";
+ if (i != 0)
+ ret += " ->";
+ }
+
+ return ret;
+}
diff --git a/tools/gn/item_tree.h b/tools/gn/item_tree.h
new file mode 100644
index 0000000..f2ac4ae
--- /dev/null
+++ b/tools/gn/item_tree.h
@@ -0,0 +1,69 @@
+// 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_ITEM_TREE_H_
+#define TOOLS_GN_ITEM_TREE_H_
+
+#include "base/containers/hash_tables.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/synchronization/lock.h"
+#include "tools/gn/label.h"
+
+class Err;
+class Item;
+class ItemNode;
+
+// Represents the full dependency tree if labeled items in the system.
+// Generally you will interact with this through the target manager, etc.
+class ItemTree {
+ public:
+ ItemTree();
+ ~ItemTree();
+
+ // This lock must be held when calling the "Locked" functions below.
+ base::Lock& lock() { return lock_; }
+
+ // Returns NULL if the item is not found.
+ //
+ // The lock must be held.
+ ItemNode* GetExistingNodeLocked(const Label& label);
+
+ // There must not be an item with this label in the tree already. Takes
+ // ownership of the pointer.
+ //
+ // The lock must be held.
+ void AddNodeLocked(ItemNode* node);
+
+ // Mark the given item as being generated. If it has no unresolved
+ // dependencies, it will be marked resolved, and the resolved state will be
+ // recursively pushed into the dependency tree. Returns an error if there was
+ // an error.
+ Err MarkItemGeneratedLocked(const Label& label);
+
+ // Fills the given vector with all known items.
+ void GetAllItemsLocked(std::vector<const Item*>* dest) const;
+
+ // Returns an error if there are unresolved dependencies, or no error if
+ // there aren't.
+ //
+ // The lock should not be held.
+ Err CheckForBadItems() const;
+
+ private:
+ Err MarkItemResolvedLocked(ItemNode* node);
+
+ // Given a set of unresolved nodes, looks for cycles and returns the error
+ // message describing any cycles it found.
+ std::string CheckForCircularDependenciesLocked(
+ const std::vector<const ItemNode*>& bad_nodes) const;
+
+ mutable base::Lock lock_;
+
+ typedef base::hash_map<Label, ItemNode*> StringToNodeHash;
+ StringToNodeHash items_; // Owning pointer.
+
+ DISALLOW_COPY_AND_ASSIGN(ItemTree);
+};
+
+#endif // TOOLS_GN_ITEM_TREE_H_
diff --git a/tools/gn/label.cc b/tools/gn/label.cc
new file mode 100644
index 0000000..f9b48da
--- /dev/null
+++ b/tools/gn/label.cc
@@ -0,0 +1,263 @@
+// 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/label.h"
+
+#include "base/logging.h"
+#include "tools/gn/err.h"
+#include "tools/gn/parse_tree.h"
+#include "tools/gn/value.h"
+
+namespace {
+
+// We print user visible label names with no trailing slash after the
+// directory name.
+std::string DirWithNoTrailingSlash(const SourceDir& dir) {
+ // Be careful not to trim if the input is just "/" or "//".
+ if (dir.value().size() > 2)
+ return dir.value().substr(0, dir.value().size() - 1);
+ return dir.value();
+}
+
+// Given the separate-out input (everything before the colon) in the dep rule,
+// computes the final build rule. Sets err on failure. On success,
+// |*used_implicit| will be set to whether the implicit current directory was
+// used. The value is used only for generating error messages.
+bool ComputeBuildLocationFromDep(const Value& input_value,
+ const SourceDir& current_dir,
+ const base::StringPiece& input,
+ SourceDir* result,
+ Err* err) {
+ // No rule, use the current locaton.
+ if (input.empty()) {
+ *result = current_dir;
+ return true;
+ }
+
+ // Don't allow directories to start with a single slash. All labels must be
+ // in the source root.
+ if (input[0] == '/' && (input.size() == 1 || input[1] != '/')) {
+ *err = Err(input_value, "Label can't start with a single slash",
+ "Labels must be either relative (no slash at the beginning) or be "
+ "absolute\ninside the source root (two slashes at the beginning).");
+ return false;
+ }
+
+ *result = current_dir.ResolveRelativeDir(input);
+ return true;
+}
+
+// Given the separated-out target name (after the colon) computes the final
+// name, using the implicit name from the previously-generated
+// computed_location if necessary. The input_value is used only for generating
+// error messages.
+bool ComputeTargetNameFromDep(const Value& input_value,
+ const SourceDir& computed_location,
+ const base::StringPiece& input,
+ std::string* result,
+ Err* err) {
+ if (!input.empty()) {
+ // Easy case: input is specified, just use it.
+ result->assign(input.data(), input.size());
+ return true;
+ }
+
+ const std::string& loc = computed_location.value();
+
+ // Use implicit name. The path will be "//", "//base/", "//base/i18n/", etc.
+ if (loc.size() <= 1) {
+ *err = Err(input_value, "This dependency name is empty");
+ return false;
+ }
+
+ size_t next_to_last_slash = loc.rfind('/', loc.size() - 2);
+ DCHECK(next_to_last_slash != std::string::npos);
+ result->assign(&loc[next_to_last_slash + 1],
+ loc.size() - next_to_last_slash - 2);
+ return true;
+}
+
+// The original value is used only for error reporting, use the |input| as the
+// input to this function (which may be a substring of the original value when
+// we're parsing toolchains.
+//
+// If the output toolchain vars are NULL, then we'll report an error if we
+// find a toolchain specified (this is used when recursively parsing toolchain
+// labels which themselves can't have toolchain specs).
+//
+// We assume that the output variables are initialized to empty so we don't
+// write them unless we need them to contain something.
+//
+// Returns true on success. On failure, the out* variables might be written to
+// but shouldn't be used.
+bool Resolve(const SourceDir& current_dir,
+ const Label& current_toolchain,
+ const Value& original_value,
+ const base::StringPiece& input,
+ SourceDir* out_dir,
+ std::string* out_name,
+ SourceDir* out_toolchain_dir,
+ std::string* out_toolchain_name,
+ Err* err) {
+ // To workaround the problem that StringPiece operator[] doesn't return a ref.
+ const char* input_str = input.data();
+
+ size_t path_separator = input.find_first_of(":(");
+ base::StringPiece location_piece;
+ base::StringPiece name_piece;
+ base::StringPiece toolchain_piece;
+ if (path_separator == std::string::npos) {
+ location_piece = input;
+ // Leave name & toolchain piece null.
+ } else {
+ location_piece = base::StringPiece(&input_str[0], path_separator);
+
+ size_t toolchain_separator = input.find('(', path_separator);
+ if (toolchain_separator == std::string::npos) {
+ name_piece = base::StringPiece(&input_str[path_separator + 1],
+ input.size() - path_separator - 1);
+ // Leave location piece null.
+ } else if (!out_toolchain_dir) {
+ // Toolchain specified but not allows in this context.
+ *err = Err(original_value, "Toolchain has a toolchain.",
+ "Your toolchain definition (inside the parens) seems to itself "
+ "have a\ntoolchain. Don't do this.");
+ return false;
+ } else {
+ // Name piece is everything between the two separators. Note that the
+ // separators may be the same (e.g. "//foo(bar)" which means empty name.
+ if (toolchain_separator > path_separator) {
+ name_piece = base::StringPiece(
+ &input_str[path_separator + 1],
+ toolchain_separator - path_separator - 1);
+ }
+
+ // Toolchain name should end in a ) and this should be the end of the
+ // string.
+ if (input[input.size() - 1] != ')') {
+ *err = Err(original_value, "Bad toolchain name.",
+ "Toolchain name must end in a \")\" at the end of the label.");
+ return false;
+ }
+
+ // Subtract off the two parens to just get the toolchain name.
+ toolchain_piece = base::StringPiece(
+ &input_str[toolchain_separator + 1],
+ input.size() - toolchain_separator - 2);
+ }
+ }
+
+ // Everything before the separator is the filename.
+ // We allow three cases:
+ // Absolute: "//foo:bar" -> /foo:bar
+ // Target in current file: ":foo" -> <currentdir>:foo
+ // Path with implicit name: "/foo" -> /foo:foo
+ if (location_piece.empty() && name_piece.empty()) {
+ // Can't use both implicit filename and name (":").
+ *err = Err(original_value, "This doesn't specify a dependency.");
+ return false;
+ }
+
+ if (!ComputeBuildLocationFromDep(original_value, current_dir, location_piece,
+ out_dir, err))
+ return false;
+
+ if (!ComputeTargetNameFromDep(original_value, *out_dir, name_piece,
+ out_name, err))
+ return false;
+
+ // Last, do the toolchains.
+ if (out_toolchain_dir) {
+ // Handle empty toolchain strings. We don't allow normal labels to be
+ // empty so we can't allow the recursive call of this function to do this
+ // check.
+ if (toolchain_piece.empty()) {
+ *out_toolchain_dir = current_toolchain.dir();
+ *out_toolchain_name = current_toolchain.name();
+ return true;
+ } else {
+ return Resolve(current_dir, current_toolchain,
+ original_value, toolchain_piece,
+ out_toolchain_dir, out_toolchain_name, NULL, NULL, err);
+ }
+ }
+ return true;
+}
+
+} // namespace
+
+Label::Label() {
+}
+
+Label::Label(const SourceDir& dir,
+ const base::StringPiece& name,
+ const SourceDir& toolchain_dir,
+ const base::StringPiece& toolchain_name)
+ : dir_(dir),
+ toolchain_dir_(toolchain_dir) {
+ name_.assign(name.data(), name.size());
+ toolchain_name_.assign(toolchain_name.data(), toolchain_name.size());
+}
+
+Label::~Label() {
+}
+
+// static
+Label Label::Resolve(const SourceDir& current_dir,
+ const Label& current_toolchain,
+ const Value& input,
+ Err* err) {
+ Label ret;
+ if (input.type() != Value::STRING) {
+ *err = Err(input, "Dependency is not a string.");
+ return ret;
+ }
+ const std::string& input_string = input.string_value();
+ if (input_string.empty()) {
+ *err = Err(input, "Dependency string is empty.");
+ return ret;
+ }
+
+ if (!::Resolve(current_dir, current_toolchain, input, input_string,
+ &ret.dir_, &ret.name_,
+ &ret.toolchain_dir_, &ret.toolchain_name_,
+ err))
+ return Label();
+ return ret;
+}
+
+Label Label::GetToolchainLabel() const {
+ return Label(toolchain_dir_, toolchain_name_,
+ SourceDir(), base::StringPiece());
+}
+
+std::string Label::GetUserVisibleName(bool include_toolchain) const {
+ std::string ret;
+ ret.reserve(dir_.value().size() + name_.size() + 1);
+
+ if (dir_.is_null())
+ return ret;
+
+ ret = DirWithNoTrailingSlash(dir_);
+ ret.push_back(':');
+ ret.append(name_);
+
+ if (include_toolchain) {
+ ret.push_back('(');
+ if (!toolchain_dir_.is_null() && !toolchain_name_.empty()) {
+ ret.append(DirWithNoTrailingSlash(toolchain_dir_));
+ ret.push_back(':');
+ ret.append(toolchain_name_);
+ }
+ ret.push_back(')');
+ }
+ return ret;
+}
+
+std::string Label::GetUserVisibleName(const Label& default_toolchain) const {
+ bool include_toolchain =
+ default_toolchain.dir() != toolchain_dir_ ||
+ default_toolchain.name() != toolchain_name_;
+ return GetUserVisibleName(include_toolchain);
+}
diff --git a/tools/gn/label.h b/tools/gn/label.h
new file mode 100644
index 0000000..b31117a
--- /dev/null
+++ b/tools/gn/label.h
@@ -0,0 +1,116 @@
+// 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_LABEL_H_
+#define TOOLS_GN_LABEL_H_
+
+#include "base/containers/hash_tables.h"
+#include "build/build_config.h"
+#include "tools/gn/source_dir.h"
+
+class Err;
+class Value;
+
+// A label represents the name of a target or some other named thing in
+// the source path. The label is always absolute and always includes a name
+// part, so it starts with a slash, and has one colon.
+class Label {
+ public:
+ Label();
+
+ // Makes a label given an already-separate out path and name.
+ // See also Resolve().
+ Label(const SourceDir& dir,
+ const base::StringPiece& name,
+ const SourceDir& toolchain_dir,
+ const base::StringPiece& toolchain_name);
+ ~Label();
+
+ // Resolives a string from a build file that may be relative to the
+ // current directory into a fully qualified label. On failure returns an
+ // is_null() label and sets the error.
+ static Label Resolve(const SourceDir& current_dir,
+ const Label& current_toolchain,
+ const Value& input,
+ Err* err);
+
+ bool is_null() const { return dir_.is_null(); }
+
+ const SourceDir& dir() const { return dir_; }
+ const std::string& name() const { return name_; }
+
+ const SourceDir& toolchain_dir() const { return toolchain_dir_; }
+ const std::string& toolchain_name() const { return toolchain_name_; }
+ Label GetToolchainLabel() const;
+
+ // Formats this label in a way that we can present to the user or expose to
+ // other parts of the system. SourceDirs end in slashes, but the user
+ // expects names like "//chrome/renderer:renderer_config" when printed. The
+ // toolchain is optionally included.
+ std::string GetUserVisibleName(bool include_toolchain) const;
+
+ // Like the above version, but automatically includes the toolchain if it's
+ // not the default one. Normally the user only cares about the toolchain for
+ // non-default ones, so this can make certain output more clear.
+ std::string GetUserVisibleName(const Label& default_toolchain) const;
+
+ bool operator==(const Label& other) const {
+ return name_ == other.name_ && dir_ == other.dir_ &&
+ toolchain_dir_ == other.toolchain_dir_ &&
+ toolchain_name_ == other.toolchain_name_;
+ }
+ bool operator!=(const Label& other) const {
+ return !operator==(other);
+ }
+ bool operator<(const Label& other) const {
+ // TODO(brettw) could be optimized to avoid an extra full string check
+ // (one for operator==, one for <).
+ if (dir_ != other.dir_)
+ return dir_ < other.dir_;
+ if (name_ != other.name_)
+ return name_ < other.name_;
+ if (toolchain_dir_ != other.toolchain_dir_)
+ return toolchain_dir_ < other.toolchain_dir_;
+ return toolchain_name_ < other.toolchain_name_;
+ }
+
+ // Returns true if the toolchain dir/name of this object matches some
+ // other object.
+ bool ToolchainsEqual(const Label& other) const {
+ return toolchain_dir_ == other.toolchain_dir_ &&
+ toolchain_name_ == other.toolchain_name_;
+ }
+
+ private:
+ SourceDir dir_;
+ std::string name_;
+
+ SourceDir toolchain_dir_;
+ std::string toolchain_name_;
+};
+
+namespace BASE_HASH_NAMESPACE {
+
+#if defined(COMPILER_GCC)
+template<> struct hash<Label> {
+ std::size_t operator()(const Label& v) const {
+ hash<std::string> stringhash;
+ return ((stringhash(v.dir().value()) * 131 +
+ stringhash(v.name())) * 131 +
+ stringhash(v.toolchain_dir().value())) * 131 +
+ stringhash(v.toolchain_name());
+ }
+};
+#elif defined(COMPILER_MSVC)
+inline size_t hash_value(const Label& v) {
+ return ((hash_value(v.dir().value()) * 131 +
+ hash_value(v.name())) * 131 +
+ hash_value(v.toolchain_dir().value())) * 131 +
+ hash_value(v.toolchain_name());
+}
+#endif // COMPILER...
+
+} // namespace BASE_HASH_NAMESPACE
+
+#endif // TOOLS_GN_LABEL_H_
diff --git a/tools/gn/label_unittest.cc b/tools/gn/label_unittest.cc
new file mode 100644
index 0000000..74eb3da
--- /dev/null
+++ b/tools/gn/label_unittest.cc
@@ -0,0 +1,88 @@
+// 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/err.h"
+#include "tools/gn/label.h"
+#include "tools/gn/value.h"
+
+namespace {
+
+struct ParseDepStringCase {
+ const char* cur_dir;
+ const char* str;
+ bool success;
+ const char* expected_dir;
+ const char* expected_name;
+ const char* expected_toolchain_dir;
+ const char* expected_toolchain_name;
+};
+
+} // namespace
+
+TEST(Label, Resolve) {
+ ParseDepStringCase cases[] = {
+ // cur input succ expected dir name tc dir tc name
+ { "//chrome/", "", false, "", "", "", "" },
+ { "//chrome/", "/", false, "", "", "", "" },
+ { "//chrome/", ":", false, "", "", "", "" },
+ { "//chrome/", "/:", false, "", "", "", "" },
+ { "//chrome/", "blah", true, "//chrome/blah/", "blah", "//t/", "d" },
+ { "//chrome/", "blah:bar", true, "//chrome/blah/", "bar", "//t/", "d" },
+ // No single-leading slash.
+ { "//chrome/", "/chrome:bar", false, "", "", "", "" },
+ // No trailing slash.
+ { "//chrome/", "/chrome/:bar", false, "", "", "", "" },
+ // Refers to root dir.
+ { "//chrome/", "//:bar", true, "//", "bar", "//t/", "d" },
+ // Implicit directory
+ { "//chrome/", ":bar", true, "//chrome/", "bar", "//t/", "d" },
+ { "//chrome/renderer/", ":bar", true, "//chrome/renderer/", "bar", "//t/", "d" },
+ // Implicit names.
+ { "//chrome/", "//base", true, "//base/", "base", "//t/", "d" },
+ { "//chrome/", "//base/i18n", true, "//base/i18n/", "i18n", "//t/", "d" },
+ { "//chrome/", "//base/i18n:foo", true, "//base/i18n/", "foo", "//t/", "d" },
+ // Toolchain parsing.
+ { "//chrome/", "//chrome:bar(//t:n)", true, "//chrome/", "bar", "//t/", "n" },
+ { "//chrome/", "//chrome:bar(//t)", true, "//chrome/", "bar", "//t/", "t" },
+ { "//chrome/", "//chrome:bar(//t:)", true, "//chrome/", "bar", "//t/", "t" },
+ { "//chrome/", "//chrome:bar()", true, "//chrome/", "bar", "//t/", "d" },
+ { "//chrome/", "//chrome:bar(foo)", true, "//chrome/", "bar", "//chrome/foo/", "foo" },
+ { "//chrome/", "//chrome:bar(:foo)", true, "//chrome/", "bar", "//chrome/", "foo" },
+ // TODO(brettw) it might be nice to make this an error:
+ //{ "//chrome/", "//chrome:bar())", false, "", "", "", "" },
+ { "//chrome/", "//chrome:bar(//t:bar(tc))", false, "", "", "", "" },
+ { "//chrome/", "//chrome:bar(()", false, "", "", "", "" },
+ { "//chrome/", "(t:b)", false, "", "", "", "" },
+ { "//chrome/", ":bar(//t/b)", true, "//chrome/", "bar", "//t/b/", "b" },
+ { "//chrome/", ":bar(/t/b)", false, "", "", "", "" },
+ { "//chrome/", ":bar(t/b)", true, "//chrome/", "bar", "//chrome/t/b/", "b" },
+ };
+
+ Label default_toolchain(SourceDir("//t/"), "d",
+ SourceDir(), std::string());
+
+ for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
+ const ParseDepStringCase& cur = cases[i];
+
+ std::string location, name;
+ Err err;
+ Value v(NULL, Value::STRING);
+ v.string_value() = cur.str;
+ Label result =
+ Label::Resolve(SourceDir(cur.cur_dir), default_toolchain, v, &err);
+ EXPECT_EQ(cur.success, !err.has_error()) << i << " " << cur.str;
+ if (!err.has_error() && cur.success) {
+ EXPECT_EQ(cur.expected_dir, result.dir().value())
+ << i << " " << cur.str;
+ EXPECT_EQ(cur.expected_name, result.name())
+ << i << " " << cur.str;
+ EXPECT_EQ(cur.expected_toolchain_dir,
+ result.toolchain_dir().value())
+ << i << " " << cur.str;
+ EXPECT_EQ(cur.expected_toolchain_name, result.toolchain_name())
+ << i << " " << cur.str;
+ }
+ }
+}
diff --git a/tools/gn/location.h b/tools/gn/location.h
new file mode 100644
index 0000000..2055125
--- /dev/null
+++ b/tools/gn/location.h
@@ -0,0 +1,77 @@
+// 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_LOCATION_H_
+#define TOOLS_GN_LOCATION_H_
+
+#include <algorithm>
+
+#include "base/logging.h"
+
+class InputFile;
+
+// Represents a place in a source file. Used for error reporting.
+class Location {
+ public:
+ Location()
+ : file_(NULL),
+ line_number_(-1),
+ char_offset_(-1) {
+ }
+ Location(const InputFile* file, int line_number, int char_offset)
+ : file_(file),
+ line_number_(line_number),
+ char_offset_(char_offset) {
+ }
+
+ const InputFile* file() const { return file_; }
+ int line_number() const { return line_number_; }
+ int char_offset() const { return char_offset_; }
+
+ bool operator==(const Location& other) const {
+ return other.file_ == file_ &&
+ other.line_number_ == line_number_ &&
+ other.char_offset_ == char_offset_;
+ }
+
+ bool operator<(const Location& other) const {
+ DCHECK(file_ == other.file_);
+ if (line_number_ != other.line_number_)
+ return line_number_ < other.line_number_;
+ return char_offset_ < other.char_offset_;
+ }
+
+ private:
+ const InputFile* file_; // Null when unset.
+ int line_number_; // -1 when unset.
+ int char_offset_; // -1 when unset.
+};
+
+// Represents a range in a source file. Used for error reporting.
+// The end is exclusive i.e. [begin, end)
+class LocationRange {
+ public:
+ LocationRange() {}
+ LocationRange(const Location& begin, const Location& end)
+ : begin_(begin),
+ end_(end) {
+ DCHECK(begin_.file() == end_.file());
+ }
+
+ const Location& begin() const { return begin_; }
+ const Location& end() const { return end_; }
+
+ LocationRange Union(const LocationRange& other) const {
+ DCHECK(begin_.file() == other.begin_.file());
+ return LocationRange(
+ begin_ < other.begin_ ? begin_ : other.begin_,
+ end_ < other.end_ ? other.end_ : end_);
+ }
+
+ private:
+ Location begin_;
+ Location end_;
+};
+
+#endif // TOOLS_GN_LOCATION_H_
diff --git a/tools/gn/ninja_build_writer.cc b/tools/gn/ninja_build_writer.cc
new file mode 100644
index 0000000..a63765c
--- /dev/null
+++ b/tools/gn/ninja_build_writer.cc
@@ -0,0 +1,165 @@
+// 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_build_writer.h"
+
+#include <fstream>
+
+#include "base/command_line.h"
+#include "base/file_util.h"
+#include "base/process/process_handle.h"
+#include "base/strings/utf_string_conversions.h"
+#include "build/build_config.h"
+#include "tools/gn/build_settings.h"
+#include "tools/gn/filesystem_utils.h"
+#include "tools/gn/input_file_manager.h"
+#include "tools/gn/scheduler.h"
+#include "tools/gn/target.h"
+
+#if defined(OS_WIN)
+#include <windows.h>
+#endif
+
+namespace {
+
+std::string GetSelfInvocationCommand(const BuildSettings* build_settings) {
+#if defined(OS_WIN)
+ wchar_t module[MAX_PATH];
+ GetModuleFileName(NULL, module, MAX_PATH);
+ //result = "\"" + WideToUTF8(module) + "\"";
+ base::FilePath executable(module);
+#elif defined(OS_MACOSX)
+ // FIXME(brettw) write this on Mac!
+ base::FilePath executable("gn");
+#else
+ base::FilePath executable =
+ base::GetProcessExecutablePath(base::GetCurrentProcessHandle());
+#endif
+
+/*
+ // Append the root path.
+ CommandLine* cmdline = CommandLine::ForCurrentProcess();
+ result += " --root=\"" + FilePathToUTF8(settings->root_path()) + "\"";
+*/
+
+ CommandLine cmdline(executable);
+ cmdline.AppendSwitchPath("--root", build_settings->root_path());
+
+ // TODO(brettw) append other parameters.
+
+#if defined(OS_WIN)
+ return WideToUTF8(cmdline.GetCommandLineString());
+#else
+ return cmdline.GetCommandLineString();
+#endif
+}
+
+} // namespace
+
+NinjaBuildWriter::NinjaBuildWriter(
+ const BuildSettings* build_settings,
+ const std::vector<const Settings*>& all_settings,
+ const std::vector<const Target*>& default_toolchain_targets,
+ std::ostream& out)
+ : build_settings_(build_settings),
+ all_settings_(all_settings),
+ default_toolchain_targets_(default_toolchain_targets),
+ out_(out),
+ path_output_(build_settings->build_dir(), ESCAPE_NINJA, true),
+ helper_(build_settings) {
+}
+
+NinjaBuildWriter::~NinjaBuildWriter() {
+}
+
+void NinjaBuildWriter::Run() {
+ WriteNinjaRules();
+ WriteSubninjas();
+ WritePhonyAndAllRules();
+}
+
+// static
+bool NinjaBuildWriter::RunAndWriteFile(
+ const BuildSettings* build_settings,
+ const std::vector<const Settings*>& all_settings,
+ const std::vector<const Target*>& default_toolchain_targets) {
+ base::FilePath ninja_file(build_settings->GetFullPath(
+ SourceFile(build_settings->build_dir().value() + "build.ninja")));
+ file_util::CreateDirectory(ninja_file.DirName());
+
+ std::ofstream file;
+ file.open(FilePathToUTF8(ninja_file).c_str(),
+ std::ios_base::out | std::ios_base::binary);
+ if (file.fail())
+ return false;
+
+ NinjaBuildWriter gen(build_settings, all_settings,
+ default_toolchain_targets, file);
+ gen.Run();
+ return true;
+}
+
+void NinjaBuildWriter::WriteNinjaRules() {
+ out_ << "rule gn\n";
+ out_ << " command = " << GetSelfInvocationCommand(build_settings_) << "\n";
+ out_ << " description = GN the world\n\n";
+
+ out_ << "build build.ninja: gn";
+
+ // Input build files.
+ std::vector<SourceFile> input_files;
+ g_scheduler->input_file_manager()->GetAllInputFileNames(&input_files);
+ for (size_t i = 0; i < input_files.size(); i++) {
+ out_ << " ";
+ path_output_.WriteFile(out_, input_files[i]);
+ }
+
+ // Other files read by the build.
+ std::vector<SourceFile> other_files = g_scheduler->GetGenDependencies();
+ for (size_t i = 0; i < other_files.size(); i++) {
+ out_ << " ";
+ path_output_.WriteFile(out_, other_files[i]);
+ }
+
+ out_ << std::endl << std::endl;
+}
+
+void NinjaBuildWriter::WriteSubninjas() {
+ for (size_t i = 0; i < all_settings_.size(); i++) {
+ out_ << "subninja ";
+ path_output_.WriteFile(out_,
+ helper_.GetNinjaFileForToolchain(all_settings_[i]));
+ out_ << std::endl;
+ }
+ out_ << std::endl;
+}
+
+void NinjaBuildWriter::WritePhonyAndAllRules() {
+ std::string all_rules;
+
+ // Write phony rules for the default toolchain (don't do other toolchains or
+ // we'll get naming conflicts).
+ for (size_t i = 0; i < default_toolchain_targets_.size(); i++) {
+ const Target* target = default_toolchain_targets_[i];
+ if (target->output_type() == Target::NONE)
+ continue; // Nothing to generate.
+
+ OutputFile target_file = helper_.GetTargetOutputFile(target);
+ if (target_file.value() != target->label().name()) {
+ out_ << "build " << target->label().name() << ": phony ";
+ path_output_.WriteFile(out_, target_file);
+ out_ << std::endl;
+ }
+
+ if (!all_rules.empty())
+ all_rules.append(" $\n ");
+ all_rules.append(target_file.value());
+ }
+
+ if (!all_rules.empty()) {
+ out_ << "\nbuild all: phony " << all_rules << std::endl;
+ out_ << "default all" << std::endl;
+ }
+}
+
diff --git a/tools/gn/ninja_build_writer.h b/tools/gn/ninja_build_writer.h
new file mode 100644
index 0000000..85548df
--- /dev/null
+++ b/tools/gn/ninja_build_writer.h
@@ -0,0 +1,53 @@
+// 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_BUILD_WRITER_H_
+#define TOOLS_GN_NINJA_BUILD_WRITER_H_
+
+#include <iosfwd>
+#include <vector>
+
+#include "tools/gn/ninja_helper.h"
+#include "tools/gn/path_output.h"
+
+class BuildSettings;
+class Settings;
+class Target;
+
+// Generates the toplevel "build.ninja" file. This references the individual
+// toolchain files and lists all input .gn files as dependencies of the
+// build itself.
+class NinjaBuildWriter {
+ public:
+ static bool RunAndWriteFile(
+ const BuildSettings* settings,
+ const std::vector<const Settings*>& all_settings,
+ const std::vector<const Target*>& default_toolchain_targets);
+
+ private:
+ NinjaBuildWriter(const BuildSettings* settings,
+ const std::vector<const Settings*>& all_settings,
+ const std::vector<const Target*>& default_toolchain_targets,
+ std::ostream& out);
+ ~NinjaBuildWriter();
+
+ void Run();
+
+ void WriteNinjaRules();
+ void WriteSubninjas();
+ void WritePhonyAndAllRules();
+
+ const BuildSettings* build_settings_;
+ std::vector<const Settings*> all_settings_;
+ std::vector<const Target*> default_toolchain_targets_;
+ std::ostream& out_;
+ PathOutput path_output_;
+
+ NinjaHelper helper_;
+
+ DISALLOW_COPY_AND_ASSIGN(NinjaBuildWriter);
+};
+
+#endif // TOOLS_GN_NINJA_BUILD_GENERATOR_H_
+
diff --git a/tools/gn/ninja_helper.cc b/tools/gn/ninja_helper.cc
new file mode 100644
index 0000000..c27c0e4
--- /dev/null
+++ b/tools/gn/ninja_helper.cc
@@ -0,0 +1,165 @@
+// 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 "tools/gn/filesystem_utils.h"
+#include "tools/gn/string_utils.h"
+#include "tools/gn/target.h"
+
+namespace {
+
+const char kLibDirWithSlash[] = "lib";
+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_;
+ ConvertPathToSystem(&build_to_src_system_no_last_slash_);
+}
+
+NinjaHelper::~NinjaHelper() {
+}
+
+std::string NinjaHelper::GetTopleveOutputDir() const {
+ return kObjectDirNoSlash;
+}
+
+std::string NinjaHelper::GetTargetOutputDir(const Target* target) const {
+ return kObjectDirNoSlash + target->label().dir().SourceAbsoluteWithOneSlash();
+}
+
+OutputFile NinjaHelper::GetNinjaFileForTarget(const Target* target) const {
+ OutputFile ret(target->settings()->toolchain_output_subdir());
+ ret.value().append(kObjectDirNoSlash);
+ AppendStringPiece(&ret.value(),
+ target->label().dir().SourceAbsoluteWithOneSlash());
+ 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:
+ name.append(target->settings()->IsWin() ? "obj" : "o");
+ break;
+
+ case SOURCE_RC:
+ name.append("res");
+ break;
+
+ 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.
+ OutputFile ret(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;
+ if (target->output_type() == Target::NONE) {
+ NOTREACHED();
+ return ret;
+ }
+
+ const char* extension;
+ if (target->output_type() == Target::NONE ||
+ target->output_type() == Target::COPY_FILES ||
+ target->output_type() == Target::CUSTOM) {
+ extension = "stamp";
+ } else {
+ extension = GetExtensionForOutputType(target->output_type(),
+ target->settings()->target_os());
+ }
+
+ // 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 loadable libraries go into the toolchain root.
+ if (target->output_type() == Target::EXECUTABLE ||
+ target->output_type() == Target::LOADABLE_MODULE ||
+ (target->settings()->IsMac() &&
+ (target->output_type() == Target::SHARED_LIBRARY ||
+ target->output_type() == Target::STATIC_LIBRARY)) ||
+ (target->settings()->IsWin() &&
+ target->output_type() == Target::SHARED_LIBRARY)) {
+ // Generate a name like "<toolchain>/<name>.<extension>".
+ ret.value().append(target->label().name());
+ ret.value().push_back('.');
+ ret.value().append(extension);
+ return ret;
+ }
+
+ // Libraries go into the library subdirectory like
+ // "<toolchain>/lib/<name>.<extension>".
+ if (target->output_type() == Target::SHARED_LIBRARY) {
+ ret.value().append(kLibDirWithSlash);
+ ret.value().append(target->label().name());
+ 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(target->label().name());
+ ret.value().push_back('.');
+ ret.value().append(extension);
+ return ret;
+}
diff --git a/tools/gn/ninja_helper.h b/tools/gn/ninja_helper.h
new file mode 100644
index 0000000..5bea29e
--- /dev/null
+++ b/tools/gn/ninja_helper.h
@@ -0,0 +1,71 @@
+// 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"
+
+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.
+ std::string 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 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_
diff --git a/tools/gn/ninja_helper_unittest.cc b/tools/gn/ninja_helper_unittest.cc
new file mode 100644
index 0000000..4aec032
--- /dev/null
+++ b/tools/gn/ninja_helper_unittest.cc
@@ -0,0 +1,73 @@
+// 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/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(),
+ toolchain(Label(SourceDir("//"), "tc", SourceDir(), std::string())),
+ settings(&build_settings, &toolchain, std::string()),
+ target(&settings,
+ Label(SourceDir("//tools/gn/"), "name",
+ SourceDir(), std::string())) {
+ 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;
+ Toolchain toolchain;
+ Settings settings;
+ 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, 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.
+}
diff --git a/tools/gn/ninja_target_writer.cc b/tools/gn/ninja_target_writer.cc
new file mode 100644
index 0000000..ed2d09d
--- /dev/null
+++ b/tools/gn/ninja_target_writer.cc
@@ -0,0 +1,550 @@
+// 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_target_writer.h"
+
+#include <fstream>
+#include <sstream>
+
+#include "base/file_util.h"
+#include "base/logging.h"
+#include "base/strings/string_util.h"
+#include "tools/gn/config_values_extractors.h"
+#include "tools/gn/err.h"
+#include "tools/gn/escape.h"
+#include "tools/gn/file_template.h"
+#include "tools/gn/location.h"
+#include "tools/gn/path_output.h"
+#include "tools/gn/scheduler.h"
+#include "tools/gn/string_utils.h"
+#include "tools/gn/target.h"
+
+namespace {
+
+static const char kCustomTargetSourceKey[] = "{{source}}";
+static const char kCustomTargetSourceNamePartKey[] = "{{source_name_part}}";
+
+struct DefineWriter {
+ void operator()(const std::string& s, std::ostream& out) const {
+ out << " -D" << s;
+ }
+};
+
+struct IncludeWriter {
+ IncludeWriter(PathOutput& path_output,
+ const NinjaHelper& h)
+ : helper(h),
+ path_output_(path_output),
+ old_inhibit_quoting_(path_output.inhibit_quoting()) {
+ // Inhibit quoting since we'll put quotes around the whole thing ourselves.
+ // Since we're writing in NINJA escaping mode, this won't actually do
+ // anything, but I think we may need to change to shell-and-then-ninja
+ // escaping for this in the future.
+ path_output_.set_inhibit_quoting(true);
+ }
+ ~IncludeWriter() {
+ path_output_.set_inhibit_quoting(old_inhibit_quoting_);
+ }
+
+ void operator()(const SourceDir& d, std::ostream& out) const {
+ out << " \"-I";
+ // It's important not to include the trailing slash on directories or on
+ // Windows it will be a backslash and the compiler might think we're
+ // escaping the quote!
+ path_output_.WriteDir(out, d, PathOutput::DIR_NO_LAST_SLASH);
+ out << "\"";
+ }
+
+ const NinjaHelper& helper;
+ PathOutput& path_output_;
+ bool old_inhibit_quoting_; // So we can put the PathOutput back.
+};
+
+} // namespace
+
+NinjaTargetWriter::NinjaTargetWriter(const Target* target, std::ostream& out)
+ : settings_(target->settings()),
+ target_(target),
+ out_(out),
+ path_output_(settings_->build_settings()->build_dir(),
+ ESCAPE_NINJA, true),
+ helper_(settings_->build_settings()) {
+}
+
+NinjaTargetWriter::~NinjaTargetWriter() {
+}
+
+void NinjaTargetWriter::Run() {
+ out_ << "arch = environment.x86\n";
+
+ if (target_->output_type() == Target::COPY_FILES) {
+ WriteCopyRules();
+ } else if (target_->output_type() == Target::CUSTOM) {
+ WriteCustomRules();
+ } else {
+ WriteCompilerVars();
+
+ std::vector<OutputFile> obj_files;
+ WriteSources(&obj_files);
+
+ WriteLinkerStuff(obj_files);
+ }
+}
+
+// static
+void NinjaTargetWriter::RunAndWriteFile(const Target* target) {
+ if (target->output_type() == Target::NONE)
+ return;
+
+ const Settings* settings = target->settings();
+ NinjaHelper helper(settings->build_settings());
+
+ base::FilePath ninja_file(settings->build_settings()->GetFullPath(
+ helper.GetNinjaFileForTarget(target).GetSourceFile(
+ settings->build_settings())));
+
+ file_util::CreateDirectory(ninja_file.DirName());
+
+ // It's rediculously faster to write to a string and then write that to
+ // disk in one operation than to use an fstream here.
+ std::stringstream file;
+ if (file.fail()) {
+ g_scheduler->FailWithError(
+ Err(Location(), "Error writing ninja file.",
+ "Unable to open \"" + FilePathToUTF8(ninja_file) + "\"\n"
+ "for writing."));
+ return;
+ }
+
+ NinjaTargetWriter gen(target, file);
+ gen.Run();
+
+ std::string contents = file.str();
+ file_util::WriteFile(ninja_file, contents.c_str(), contents.size());
+}
+
+void NinjaTargetWriter::WriteCopyRules() {
+ // The dest dir should be inside the output dir so we can just remove the
+ // prefix and get ninja-relative paths.
+ const std::string& output_dir =
+ settings_->build_settings()->build_dir().value();
+ const std::string& dest_dir = target_->destdir().value();
+ DCHECK(StartsWithASCII(dest_dir, output_dir, true));
+ std::string relative_dest_dir(&dest_dir[output_dir.size()],
+ dest_dir.size() - output_dir.size());
+
+ const Target::FileList& sources = target_->sources();
+ std::vector<OutputFile> dest_files;
+ dest_files.reserve(sources.size());
+
+ // Write out rules for each file copied.
+ for (size_t i = 0; i < sources.size(); i++) {
+ const SourceFile& input_file = sources[i];
+
+ // The files should have the same name but in the dest dir.
+ base::StringPiece name_part = FindFilename(&input_file.value());
+ OutputFile dest_file(relative_dest_dir);
+ AppendStringPiece(&dest_file.value(), name_part);
+
+ dest_files.push_back(dest_file);
+
+ out_ << "build ";
+ path_output_.WriteFile(out_, dest_file);
+ out_ << ": copy ";
+ path_output_.WriteFile(out_, input_file);
+ out_ << std::endl;
+ }
+
+ // Write out the rule for the target to copy all of them.
+ out_ << std::endl << "build ";
+ path_output_.WriteFile(out_, helper_.GetTargetOutputFile(target_));
+ out_ << ": stamp";
+ for (size_t i = 0; i < dest_files.size(); i++) {
+ out_ << " ";
+ path_output_.WriteFile(out_, dest_files[i]);
+ }
+ out_ << std::endl;
+
+ // TODO(brettw) need some kind of stamp file for depending on this, as well
+ // as order_only=prebuild.
+}
+
+void NinjaTargetWriter::WriteCustomRules() {
+ // Make a unique name for this rule.
+ std::string target_label = target_->label().GetUserVisibleName(true);
+ std::string custom_rule_name(target_label);
+ ReplaceChars(custom_rule_name, ":/()", "_", &custom_rule_name);
+ custom_rule_name.append("_rule");
+
+ // Run the script from the dir of the BUILD file. This has no trailing
+ // slash.
+ const SourceDir& script_cd = target_->label().dir();
+ std::string script_cd_to_root = InvertDir(script_cd);
+ if (script_cd_to_root.empty()) {
+ script_cd_to_root = ".";
+ } else {
+ // Remove trailing slash
+ DCHECK(script_cd_to_root[script_cd_to_root.size() - 1] == '/');
+ script_cd_to_root.resize(script_cd_to_root.size() - 1);
+ }
+
+ std::string script_relative_to_cd =
+ script_cd_to_root + target_->script().value();
+
+ bool no_sources = target_->sources().empty();
+
+ // Use a unique name for the response file when there are multiple build
+ // steps so that they don't stomp on each other.
+ std::string rspfile = custom_rule_name;
+ if (!no_sources)
+ rspfile += ".$unique_name";
+ rspfile += ".rsp";
+
+ // First write the custom rule.
+ out_ << "rule " << custom_rule_name << std::endl;
+ out_ << " command = $pythonpath gyp-win-tool action-wrapper $arch "
+ << rspfile << " ";
+ path_output_.WriteDir(out_, script_cd, PathOutput::DIR_NO_LAST_SLASH);
+ out_ << std::endl;
+ out_ << " description = CUSTOM " << target_label << std::endl;
+ out_ << " restat = 1" << std::endl;
+ out_ << " rspfile = " << rspfile << std::endl;
+
+ // The build command goes in the rsp file.
+ out_ << " rspfile_content = $pythonpath " << script_relative_to_cd;
+ for (size_t i = 0; i < target_->script_args().size(); i++) {
+ const std::string& arg = target_->script_args()[i];
+ out_ << " ";
+ WriteCustomArg(arg);
+ }
+ out_ << std::endl << std::endl;
+
+ // Precompute the common dependencies for each step. This includes the
+ // script itself (changing the script should force a rebuild) and any data
+ // files.
+ std::ostringstream common_deps_stream;
+ path_output_.WriteFile(common_deps_stream, target_->script());
+ const Target::FileList& datas = target_->data();
+ for (size_t i = 0; i < datas.size(); i++) {
+ common_deps_stream << " ";
+ path_output_.WriteFile(common_deps_stream, datas[i]);
+ }
+ const std::string& common_deps = common_deps_stream.str();
+
+ // Collects all output files for writing below.
+ std::vector<OutputFile> output_files;
+
+ if (no_sources) {
+ // No sources, write a rule that invokes the script once with the
+ // outputs as outputs, and the data as inputs.
+ out_ << "build";
+ const Target::FileList& outputs = target_->outputs();
+ for (size_t i = 0; i < outputs.size(); i++) {
+ OutputFile output_path(
+ RemovePrefix(outputs[i].value(),
+ settings_->build_settings()->build_dir().value()));
+ output_files.push_back(output_path);
+ out_ << " ";
+ path_output_.WriteFile(out_, output_path);
+ }
+ out_ << ": " << custom_rule_name << " " << common_deps << std::endl;
+ } else {
+ // Write separate rules for each input source file.
+ WriteCustomSourceRules(custom_rule_name, common_deps, script_cd,
+ script_cd_to_root, &output_files);
+ }
+ out_ << std::endl;
+
+ // Last write a stamp rule to collect all outputs.
+ out_ << "build ";
+ path_output_.WriteFile(out_, helper_.GetTargetOutputFile(target_));
+ out_ << ": stamp";
+ for (size_t i = 0; i < output_files.size(); i++) {
+ out_ << " ";
+ path_output_.WriteFile(out_, output_files[i]);
+ }
+ out_ << std::endl;
+}
+
+void NinjaTargetWriter::WriteCustomArg(const std::string& arg) {
+ // This can be optimized if it's called a lot.
+ EscapeOptions options;
+ options.mode = ESCAPE_NINJA;
+ std::string output_str = EscapeString(arg, options);
+
+ // Do this substitution after escaping our our $ will be escaped (which we
+ // don't want).
+ ReplaceSubstringsAfterOffset(&output_str, 0, FileTemplate::kSource,
+ "${source}");
+ ReplaceSubstringsAfterOffset(&output_str, 0, FileTemplate::kSourceNamePart,
+ "${source_name_part}");
+ out_ << output_str;
+}
+
+void NinjaTargetWriter::WriteCustomSourceRules(
+ const std::string& custom_rule_name,
+ const std::string& common_deps,
+ const SourceDir& script_cd,
+ const std::string& script_cd_to_root,
+ std::vector<OutputFile>* output_files) {
+ // Construct the template for generating the output files from each source.
+ const Target::FileList& outputs = target_->outputs();
+ std::vector<std::string> output_template_args;
+ for (size_t i = 0; i < outputs.size(); i++) {
+ // All outputs should be in the output dir.
+ output_template_args.push_back(
+ RemovePrefix(outputs[i].value(),
+ settings_->build_settings()->build_dir().value()));
+ }
+ FileTemplate output_template(output_template_args);
+
+ // Prevent re-allocating each time by initializing outside the loop.
+ std::vector<std::string> output_template_result;
+
+ // Path output formatter for wrigin source paths passed to the script.
+ PathOutput script_source_path_output(script_cd, ESCAPE_SHELL, true);
+
+ const Target::FileList& sources = target_->sources();
+ for (size_t i = 0; i < sources.size(); i++) {
+ // Write outputs for this source file computed by the template.
+ out_ << "build";
+ output_template.ApplyString(sources[i].value(), &output_template_result);
+ for (size_t out_i = 0; out_i < output_template_result.size(); out_i++) {
+ OutputFile output_path(output_template_result[out_i]);
+ output_files->push_back(output_path);
+ out_ << " ";
+ path_output_.WriteFile(out_, output_path);
+ }
+
+ out_ << ": " << custom_rule_name
+ << " " << common_deps
+ << " ";
+ path_output_.WriteFile(out_, sources[i]);
+ out_ << std::endl;
+
+ out_ << " unique_name = " << i << std::endl;
+
+ // The source file here should be relative to the script directory since
+ // this is the variable passed to the script. Here we slightly abuse the
+ // OutputFile object by putting a non-output-relative path in it to signal
+ // that the PathWriter should not prepend directories.
+ out_ << " source = ";
+ script_source_path_output.WriteFile(out_, sources[i]);
+ out_ << std::endl;
+
+ out_ << " source_name_part = "
+ << FindFilenameNoExtension(&sources[i].value()).as_string()
+ << std::endl;
+ }
+}
+
+void NinjaTargetWriter::WriteCompilerVars() {
+ // Defines.
+ out_ << "defines =";
+ RecursiveTargetConfigToStream(target_, &ConfigValues::defines,
+ DefineWriter(), out_);
+ out_ << std::endl;
+
+ // Includes.
+ out_ << "includes =";
+ RecursiveTargetConfigToStream(target_, &ConfigValues::includes,
+ IncludeWriter(path_output_, helper_), out_);
+
+ out_ << std::endl;
+
+ // C flags and friends.
+ out_ << "cflags =";
+ RecursiveTargetConfigStringsToStream(target_, &ConfigValues::cflags, out_);
+ out_ << std::endl;
+ out_ << "cflags_c =";
+ RecursiveTargetConfigStringsToStream(target_, &ConfigValues::cflags_c, out_);
+ out_ << std::endl;
+ out_ << "cflags_cc =";
+ RecursiveTargetConfigStringsToStream(target_, &ConfigValues::cflags_cc, out_);
+ out_ << std::endl;
+
+ out_ << std::endl;
+}
+
+void NinjaTargetWriter::WriteSources(
+ std::vector<OutputFile>* object_files) {
+ const Target::FileList& sources = target_->sources();
+ object_files->reserve(sources.size());
+
+ for (size_t i = 0; i < sources.size(); i++) {
+ const SourceFile& input_file = sources[i];
+
+ SourceFileType input_file_type = GetSourceFileType(input_file,
+ settings_->target_os());
+ if (input_file_type == SOURCE_UNKNOWN)
+ continue; // Skip unknown file types.
+ const char* command = GetCommandForSourceType(input_file_type);
+ if (!command)
+ 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_ << std::endl;
+ }
+ out_ << std::endl;
+}
+
+void NinjaTargetWriter::WriteLinkerStuff(
+ const std::vector<OutputFile>& object_files) {
+ // 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.value().assign(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;
+ }
+
+ // Linker flags, append manifest flag on Windows to reference our file.
+ out_ << "ldflags =";
+ RecursiveTargetConfigStringsToStream(target_, &ConfigValues::ldflags, out_);
+ if (settings_->IsWin())
+ out_ << " /MANIFEST /ManifestFile:";
+ path_output_.WriteFile(out_, windows_manifest);
+ { // HACK ERASEME BRETTW FIXME
+ out_ << " /DEBUG /MACHINE:X86 /LIBPATH:\"C:\\Program Files (x86)\\Windows Kits\\8.0\\Lib\\win8\\um\\x86\" /DELAYLOAD:dbghelp.dll /DELAYLOAD:dwmapi.dll /DELAYLOAD:shell32.dll /DELAYLOAD:uxtheme.dll /safeseh /dynamicbase /ignore:4199 /ignore:4221 /nxcompat /SUBSYSTEM:CONSOLE /INCREMENTAL /FIXED:NO /DYNAMICBASE:NO wininet.lib dnsapi.lib version.lib msimg32.lib ws2_32.lib usp10.lib psapi.lib dbghelp.lib winmm.lib shlwapi.lib kernel32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib user32.lib uuid.lib odbc32.lib odbccp32.lib delayimp.lib /NXCOMPAT";
+ }
+ out_ << std::endl;
+
+ // Libraries to link.
+ out_ << "libs =" << std::endl;
+
+ // 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 = OutputFile(target_->label().name() + ".dll");
+ } else {
+ NOTREACHED(); // TODO(brettw) write this.
+ }
+ } else {
+ internal_output_file = external_output_file;
+ }
+
+ // TODO(brettw) should we append data files to this?
+
+ // In Python see "self.ninja.build(output, command, input,"
+ 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_ << ": " << GetCommandForTargetType();
+ for (size_t i = 0; i < object_files.size(); i++) {
+ out_ << " ";
+ path_output_.WriteFile(out_, object_files[i]);
+ }
+
+ if (target_->output_type() == Target::EXECUTABLE ||
+ target_->output_type() == Target::SHARED_LIBRARY ||
+ target_->output_type() == Target::LOADABLE_MODULE) {
+ const std::vector<const Target*>& deps = target_->deps();
+ const std::set<const Target*>& inherited = target_->inherited_libraries();
+
+ // Now append linkable libraries to the linker command.
+ for (size_t i = 0; i < deps.size(); i++) {
+ if (deps[i]->IsLinkable() &&
+ inherited.find(deps[i]) == inherited.end()) {
+ out_ << " ";
+ path_output_.WriteFile(out_,
+ helper_.GetTargetOutputFile(target_->deps()[i]));
+ }
+ }
+ for (std::set<const Target*>::const_iterator i = inherited.begin();
+ i != inherited.end(); ++i) {
+ out_ << " ";
+ path_output_.WriteFile(out_, helper_.GetTargetOutputFile(*i));
+ }
+ }
+ out_ << std::endl;
+
+ if (target_->output_type() == Target::SHARED_LIBRARY) {
+ out_ << " soname = ";
+ path_output_.WriteFile(out_, internal_output_file);
+ out_ << std::endl;
+
+ out_ << " lib = ";
+ path_output_.WriteFile(out_, internal_output_file);
+ out_ << std::endl;
+
+ 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 here.
+
+ out_ << std::endl;
+}
+
+const char* NinjaTargetWriter::GetCommandForSourceType(
+ SourceFileType type) const {
+ if (type == SOURCE_C)
+ return "cc";
+ if (type == SOURCE_CC)
+ return "cxx";
+
+ // TODO(brettw) asm files.
+
+ if (settings_->IsMac()) {
+ if (type == SOURCE_M)
+ return "objc";
+ if (type == SOURCE_MM)
+ return "objcxx";
+ }
+
+ if (settings_->IsWin()) {
+ if (type == SOURCE_RC)
+ return "rc";
+ }
+
+ // TODO(brettw) stuff about "S" files on non-Windows.
+ return NULL;
+}
+
+const char* NinjaTargetWriter::GetCommandForTargetType() const {
+ if (target_->output_type() == Target::NONE) {
+ NOTREACHED();
+ return "";
+ }
+
+ if (target_->output_type() == Target::STATIC_LIBRARY) {
+ // TODO(brettw) stuff about standalong static libraryes on Unix in
+ // WriteTarget in the Python one, and lots of postbuild steps.
+ return "alink";
+ }
+
+ if (target_->output_type() == Target::SHARED_LIBRARY)
+ return "solink";
+
+ return "link";
+}
diff --git a/tools/gn/ninja_target_writer.h b/tools/gn/ninja_target_writer.h
new file mode 100644
index 0000000..5e6827d
--- /dev/null
+++ b/tools/gn/ninja_target_writer.h
@@ -0,0 +1,67 @@
+// 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_TARGET_WRITER_H_
+#define TOOLS_GN_NINJA_TARGET_WRITER_H_
+
+#include <iosfwd>
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/files/file_path.h"
+#include "tools/gn/filesystem_utils.h"
+#include "tools/gn/ninja_helper.h"
+#include "tools/gn/path_output.h"
+#include "tools/gn/settings.h"
+
+class Target;
+
+// Generates one target's ".ninja" file. The toplevel "build.ninja" file is
+// generated by the NinjaBuildGenerator.
+class NinjaTargetWriter {
+ public:
+ NinjaTargetWriter(const Target* target, std::ostream& out);
+ ~NinjaTargetWriter();
+
+ void Run();
+
+ static void RunAndWriteFile(const Target* target);
+
+ private:
+ void WriteCopyRules();
+
+ void WriteCustomRules();
+ void WriteCustomArg(const std::string& arg);
+
+ // Writs the rules for compiling each source, writing all output files
+ // to the given vector.
+ //
+ // common_deps is a precomputed string of all ninja files that are common
+ // to each build step. This is added to each one.
+ void WriteCustomSourceRules(const std::string& custom_rule_name,
+ const std::string& common_deps,
+ const SourceDir& script_cd,
+ const std::string& script_cd_to_root,
+ std::vector<OutputFile>* output_files);
+
+ void WriteCompilerVars();
+ void WriteSources(std::vector<OutputFile>* object_files);
+ void WriteLinkerStuff(const std::vector<OutputFile>& object_files);
+
+ // Returns NULL if the source type should not be compiled on this target.
+ const char* GetCommandForSourceType(SourceFileType type) const;
+
+ const char* GetCommandForTargetType() const;
+
+ const Settings* settings_; // Non-owning.
+ const Target* target_; // Non-owning.
+ std::ostream& out_;
+ PathOutput path_output_;
+
+ NinjaHelper helper_;
+
+ DISALLOW_COPY_AND_ASSIGN(NinjaTargetWriter);
+};
+
+#endif // TOOLS_GN_NINJA_TARGET_WRITER_H_
diff --git a/tools/gn/ninja_toolchain_writer.cc b/tools/gn/ninja_toolchain_writer.cc
new file mode 100644
index 0000000..0e38b8c
--- /dev/null
+++ b/tools/gn/ninja_toolchain_writer.cc
@@ -0,0 +1,94 @@
+// 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_toolchain_writer.h"
+
+#include <fstream>
+
+#include "base/file_util.h"
+#include "base/strings/stringize_macros.h"
+#include "tools/gn/build_settings.h"
+#include "tools/gn/settings.h"
+#include "tools/gn/target.h"
+#include "tools/gn/toolchain.h"
+
+NinjaToolchainWriter::NinjaToolchainWriter(
+ const Settings* settings,
+ const std::vector<const Target*>& targets,
+ std::ostream& out)
+ : settings_(settings),
+ targets_(targets),
+ out_(out),
+ path_output_(settings_->build_settings()->build_dir(),
+ ESCAPE_NINJA, true),
+ helper_(settings->build_settings()) {
+}
+
+NinjaToolchainWriter::~NinjaToolchainWriter() {
+}
+
+void NinjaToolchainWriter::Run() {
+ WriteRules();
+ WriteSubninjas();
+}
+
+// static
+bool NinjaToolchainWriter::RunAndWriteFile(
+ const Settings* settings,
+ const std::vector<const Target*>& targets) {
+ NinjaHelper helper(settings->build_settings());
+ base::FilePath ninja_file(settings->build_settings()->GetFullPath(
+ helper.GetNinjaFileForToolchain(settings).GetSourceFile(
+ settings->build_settings())));
+ file_util::CreateDirectory(ninja_file.DirName());
+
+ std::ofstream file;
+ file.open(FilePathToUTF8(ninja_file).c_str(),
+ std::ios_base::out | std::ios_base::binary);
+ if (file.fail())
+ return false;
+
+ NinjaToolchainWriter gen(settings, targets, file);
+ gen.Run();
+ return true;
+}
+
+void NinjaToolchainWriter::WriteRules() {
+ const Toolchain* tc = settings_->toolchain();
+ std::string indent(" ");
+
+ for (int i = Toolchain::TYPE_NONE + 1; i < Toolchain::TYPE_NUMTYPES; i++) {
+ Toolchain::ToolType tool_type = static_cast<Toolchain::ToolType>(i);
+ const Toolchain::Tool& tool = tc->GetTool(tool_type);
+ if (tool.empty())
+ continue;
+
+ out_ << "rule " << 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(deps);
+ WRITE_ARG(description);
+ WRITE_ARG(pool);
+ WRITE_ARG(restat);
+ WRITE_ARG(rspfile);
+ WRITE_ARG(rspfile_content);
+ #undef WRITE_ARG
+ }
+ out_ << std::endl;
+}
+
+void NinjaToolchainWriter::WriteSubninjas() {
+ for (size_t i = 0; i < targets_.size(); i++) {
+ if (targets_[i]->output_type() != Target::NONE) {
+ out_ << "subninja ";
+ path_output_.WriteFile(out_, helper_.GetNinjaFileForTarget(targets_[i]));
+ out_ << std::endl;
+ }
+ }
+ out_ << std::endl;
+}
diff --git a/tools/gn/ninja_toolchain_writer.h b/tools/gn/ninja_toolchain_writer.h
new file mode 100644
index 0000000..71759ef
--- /dev/null
+++ b/tools/gn/ninja_toolchain_writer.h
@@ -0,0 +1,46 @@
+// 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_TOOLCHAIN_WRITER_H_
+#define TOOLS_GN_NINJA_TOOLCHAIN_WRITER_H_
+
+#include <iosfwd>
+#include <vector>
+
+#include "tools/gn/ninja_helper.h"
+#include "tools/gn/path_output.h"
+
+class BuildSettings;
+class Settings;
+class Target;
+
+class NinjaToolchainWriter {
+ public:
+ // Takes the settings for the toolchain, as well as the list of all targets
+ // assicoated with the toolchain.
+ static bool RunAndWriteFile(const Settings* settings,
+ const std::vector<const Target*>& targets);
+
+ private:
+ NinjaToolchainWriter(const Settings* settings,
+ const std::vector<const Target*>& targets,
+ std::ostream& out);
+ ~NinjaToolchainWriter();
+
+ void Run();
+
+ void WriteRules();
+ void WriteSubninjas();
+
+ const Settings* settings_;
+ std::vector<const Target*> targets_;
+ std::ostream& out_;
+ PathOutput path_output_;
+
+ NinjaHelper helper_;
+
+ DISALLOW_COPY_AND_ASSIGN(NinjaToolchainWriter);
+};
+
+#endif // TOOLS_GN_NINJA_TOOLCHAIN_WRITER_H_
diff --git a/tools/gn/ninja_writer.cc b/tools/gn/ninja_writer.cc
new file mode 100644
index 0000000..8b69a3f
--- /dev/null
+++ b/tools/gn/ninja_writer.cc
@@ -0,0 +1,64 @@
+// 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_writer.h"
+
+#include "tools/gn/location.h"
+#include "tools/gn/ninja_build_writer.h"
+#include "tools/gn/ninja_toolchain_writer.h"
+
+
+NinjaWriter::NinjaWriter(const BuildSettings* build_settings)
+ : build_settings_(build_settings) {
+}
+
+NinjaWriter::~NinjaWriter() {
+}
+
+// static
+bool NinjaWriter::RunAndWriteFiles(const BuildSettings* build_settings) {
+ NinjaWriter writer(build_settings);
+ return writer.WriteRootBuildfiles();
+}
+
+bool NinjaWriter::WriteRootBuildfiles() {
+ // Categorize all targets by toolchain.
+ typedef std::map<Label, std::vector<const Target*> > CategorizedMap;
+ CategorizedMap categorized;
+
+ std::vector<const Target*> all_targets;
+ build_settings_->target_manager().GetAllTargets(&all_targets);
+ for (size_t i = 0; i < all_targets.size(); i++) {
+ categorized[all_targets[i]->label().GetToolchainLabel()].push_back(
+ all_targets[i]);
+ }
+
+ Label default_label =
+ build_settings_->toolchain_manager().GetDefaultToolchainUnlocked();
+
+ // Write out the toolchain buildfiles, and also accumulate the set of
+ // all settings and find the list of targets in the default toolchain.
+ std::vector<const Settings*> all_settings;
+ const std::vector<const Target*>* default_targets = NULL;
+ for (CategorizedMap::const_iterator i = categorized.begin();
+ i != categorized.end(); ++i) {
+ const Settings* settings;
+ {
+ base::AutoLock lock(build_settings_->item_tree().lock());
+ Err ignored;
+ settings =
+ build_settings_->toolchain_manager().GetSettingsForToolchainLocked(
+ LocationRange(), i->first, &ignored);
+ }
+ if (i->first == default_label)
+ default_targets = &i->second;
+ all_settings.push_back(settings);
+ if (!NinjaToolchainWriter::RunAndWriteFile(settings, i->second))
+ return false;
+ }
+
+ // Write the root buildfile.
+ return NinjaBuildWriter::RunAndWriteFile(build_settings_, all_settings,
+ *default_targets);
+}
diff --git a/tools/gn/ninja_writer.h b/tools/gn/ninja_writer.h
new file mode 100644
index 0000000..9b6d2c1
--- /dev/null
+++ b/tools/gn/ninja_writer.h
@@ -0,0 +1,27 @@
+// 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_WRITER_H_
+#define TOOLS_GN_NINJA_WRITER_H_
+
+#include "base/basictypes.h"
+
+class BuildSettings;
+
+class NinjaWriter {
+ public:
+ static bool RunAndWriteFiles(const BuildSettings* build_settings);
+
+ private:
+ NinjaWriter(const BuildSettings* build_settings);
+ ~NinjaWriter();
+
+ bool WriteRootBuildfiles();
+
+ const BuildSettings* build_settings_;
+
+ DISALLOW_COPY_AND_ASSIGN(NinjaWriter);
+};
+
+#endif // TOOLS_GN_NINJA_WRITER_H_
diff --git a/tools/gn/operators.cc b/tools/gn/operators.cc
new file mode 100644
index 0000000..afded9f
--- /dev/null
+++ b/tools/gn/operators.cc
@@ -0,0 +1,573 @@
+// 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/operators.h"
+
+#include "base/strings/string_number_conversions.h"
+#include "tools/gn/err.h"
+#include "tools/gn/parse_tree.h"
+#include "tools/gn/scope.h"
+#include "tools/gn/token.h"
+#include "tools/gn/value.h"
+
+namespace {
+
+const char kSourcesName[] = "sources";
+
+// Applies the sources assignment filter from the given scope to each element
+// of source (can be a list or a string), appending it to dest if it doesn't
+// match.
+void AppendFilteredSourcesToValue(const Scope* scope,
+ const Value& source,
+ Value* dest) {
+ const PatternList* filter = scope->GetSourcesAssignmentFilter();
+
+ const std::vector<Value>& source_list = source.list_value();
+
+ if (source.type() == Value::STRING) {
+ if (!filter || filter->is_empty() ||
+ !filter->MatchesValue(source))
+ dest->list_value().push_back(source);
+ return;
+ }
+
+ // Otherwise source is a list.
+ DCHECK(source.type() == Value::LIST);
+ if (!filter || filter->is_empty()) {
+ // No filter, append everything.
+ for (size_t i = 0; i < source_list.size(); i++)
+ dest->list_value().push_back(source_list[i]);
+ return;
+ }
+
+ // Note: don't reserve() the dest vector here since that actually hurts
+ // the allocation pattern when the build script is doing multiple small
+ // additions.
+ for (size_t i = 0; i < source_list.size(); i++) {
+ if (!filter->MatchesValue(source_list[i]))
+ dest->list_value().push_back(source_list[i]);
+ }
+}
+
+void RemoveMatchesFromList(const BinaryOpNode* op_node,
+ Value* list,
+ const Value& to_remove,
+ Err* err) {
+ std::vector<Value>& v = list->list_value();
+ switch (to_remove.type()) {
+ case Value::INTEGER: // Filter out the individual int/string.
+ case Value::STRING: {
+ bool found_match = false;
+ for (size_t i = 0; i < v.size(); /* nothing */) {
+ if (v[i] == to_remove) {
+ found_match = true;
+ v.erase(v.begin() + i);
+ } else {
+ i++;
+ }
+ }
+ if (!found_match) {
+ *err = Err(to_remove.origin()->GetRange(), "Item not found",
+ "You were trying to remove \"" + to_remove.ToString() +
+ "\"\nfrom the list but it wasn't there.");
+ }
+ break;
+ }
+
+ case Value::LIST: // Filter out each individual thing.
+ for (size_t i = 0; i < to_remove.list_value().size(); i++) {
+ // TODO(brettw) if the nested item is a list, we may want to search
+ // for the literal list rather than remote the items in it.
+ RemoveMatchesFromList(op_node, list, to_remove.list_value()[i], err);
+ if (err->has_error())
+ return;
+ }
+ break;
+
+ default:
+ break;
+ }
+}
+
+// Assignment -----------------------------------------------------------------
+
+Value ExecuteEquals(Scope* scope,
+ const BinaryOpNode* op_node,
+ const Token& left,
+ const Value& right,
+ Err* err) {
+ const Value* old_value = scope->GetValue(left.value(), false);
+ if (old_value) {
+ if (scope->IsSetButUnused(left.value())) {
+ // Throw an error for re-assigning without using the value first. The
+ // exception is that you can overwrite an empty list with another list
+ // since this is the way to get around the "can't overwrite a nonempty
+ // list with another nonempty list" restriction.
+ if (old_value->type() != Value::LIST ||
+ !old_value->list_value().empty()) {
+ *err = Err(op_node->left()->GetRange(), "Overwriting unused variable.",
+ "This overwrites a previous assignment to \"" +
+ left.value().as_string() + "\" that had no effect.");
+ err->AppendSubErr(Err(*scope->GetValue(left.value()),
+ "Previously set here.",
+ "Maybe you wanted \"+=\" to append instead?"));
+ return Value();
+ }
+ } else {
+ // Throw an error when overwriting a nonempty list with another nonempty
+ // list item. This is to detect the case where you write
+ // defines = ["FOO"]
+ // and you overwrote inherited ones, when instead you mean to append:
+ // defines += ["FOO"]
+ if (old_value->type() == Value::LIST &&
+ !old_value->list_value().empty() &&
+ right.type() == Value::LIST &&
+ !right.list_value().empty()) {
+ *err = Err(op_node->left()->GetRange(), "Replacing nonempty list.",
+ std::string("This overwrites a previously-defined nonempty list ") +
+ "(length " + base::IntToString(old_value->list_value().size()) +
+ ").");
+ err->AppendSubErr(Err(*old_value, "for previous definition",
+ "with another one (length " +
+ base::IntToString(right.list_value().size()) + "). Did you mean " +
+ "\"+=\" to append instead? If you\nreally want to do this, do\n " +
+ left.value().as_string() + " = []\nbefore reassigning."));
+ return Value();
+ }
+ }
+ }
+ if (err->has_error())
+ return Value();
+
+ if (right.type() == Value::LIST && left.value() == kSourcesName) {
+ // Assigning to sources, filter the list. Here we do the filtering and
+ // copying in one step to save an extra list copy (the lists may be
+ // long).
+ Value* set_value = scope->SetValue(left.value(),
+ Value(op_node, Value::LIST), op_node);
+ set_value->list_value().reserve(right.list_value().size());
+ AppendFilteredSourcesToValue(scope, right, set_value);
+ } else {
+ // Normal value set, just copy it.
+ scope->SetValue(left.value(), right, op_node->right());
+ }
+ return Value();
+}
+
+// allow_type_conversion indicates if we're allowed to change the type of the
+// left value. This is set to true when doing +, and false when doing +=.
+void ValuePlusEquals(const Scope* scope,
+ const BinaryOpNode* op_node,
+ const Token& left_token,
+ Value* left,
+ const Value& right,
+ bool allow_type_conversion,
+ Err* err) {
+ switch (left->type()) {
+ // Left-hand-side int.
+ case Value::INTEGER:
+ switch (right.type()) {
+ case Value::INTEGER: // int + int -> addition.
+ left->int_value() += right.int_value();
+ return;
+
+ case Value::STRING: // int + string -> string concat.
+ if (allow_type_conversion) {
+ *left = Value(op_node,
+ base::Int64ToString(left->int_value()) + right.string_value());
+ return;
+ }
+ break;
+
+ default:
+ break;
+ }
+ break;
+
+ // Left-hand-side string.
+ case Value::STRING:
+ switch (right.type()) {
+ case Value::INTEGER: // string + int -> string concat.
+ left->string_value().append(base::Int64ToString(right.int_value()));
+ return;
+
+ case Value::STRING: // string + string -> string contat.
+ left->string_value().append(right.string_value());
+ return;
+
+ default:
+ break;
+ }
+ break;
+
+ // Left-hand-side list.
+ case Value::LIST:
+ switch (right.type()) {
+ case Value::INTEGER: // list + integer -> list append.
+ case Value::STRING: // list + string -> list append.
+ if (left_token.value() == kSourcesName)
+ AppendFilteredSourcesToValue(scope, right, left);
+ else
+ left->list_value().push_back(right);
+ return;
+
+ case Value::LIST: // list + list -> list concat.
+ if (left_token.value() == kSourcesName) {
+ // Filter additions through the assignment filter.
+ AppendFilteredSourcesToValue(scope, right, left);
+ } else {
+ // Normal list concat.
+ for (size_t i = 0; i < right.list_value().size(); i++)
+ left->list_value().push_back(right.list_value()[i]);
+ }
+ return;
+
+ default:
+ break;
+ }
+
+ default:
+ break;
+ }
+
+ *err = Err(op_node->op(), "Incompatible types to add.",
+ std::string("I see a ") + Value::DescribeType(left->type()) + " and a " +
+ Value::DescribeType(right.type()) + ".");
+}
+
+Value ExecutePlusEquals(Scope* scope,
+ const BinaryOpNode* op_node,
+ const Token& left,
+ const Value& right,
+ Err* err) {
+ // We modify in-place rather than doing read-modify-write to avoid
+ // copying large lists.
+ Value* left_value =
+ scope->GetValueForcedToCurrentScope(left.value(), op_node);
+ if (!left_value) {
+ *err = Err(left, "Undefined variable for +=.",
+ "I don't have something with this name in scope now.");
+ return Value();
+ }
+ ValuePlusEquals(scope, op_node, left, left_value, right, false, err);
+ left_value->set_origin(op_node);
+ scope->MarkUnused(left.value());
+ return Value();
+}
+
+void ValueMinusEquals(const BinaryOpNode* op_node,
+ Value* left,
+ const Value& right,
+ bool allow_type_conversion,
+ Err* err) {
+ switch (left->type()) {
+ // Left-hand-side int.
+ case Value::INTEGER:
+ switch (right.type()) {
+ case Value::INTEGER: // int - int -> subtraction.
+ left->int_value() -= right.int_value();
+ return;
+
+ default:
+ break;
+ }
+ break;
+
+ // Left-hand-side string.
+ case Value::STRING:
+ break; // All are errors.
+
+ // Left-hand-side list.
+ case Value::LIST:
+ RemoveMatchesFromList(op_node, left, right, err);
+ return;
+
+ default:
+ break;
+ }
+
+ *err = Err(op_node->op(), "Incompatible types to add.",
+ std::string("I see a ") + Value::DescribeType(left->type()) + " and a " +
+ Value::DescribeType(right.type()) + ".");
+}
+
+Value ExecuteMinusEquals(Scope* scope,
+ const BinaryOpNode* op_node,
+ const Token& left,
+ const Value& right,
+ Err* err) {
+ Value* left_value =
+ scope->GetValueForcedToCurrentScope(left.value(), op_node);
+ if (!left_value) {
+ *err = Err(left, "Undefined variable for -=.",
+ "I don't have something with this name in scope now.");
+ return Value();
+ }
+ ValueMinusEquals(op_node, left_value, right, false, err);
+ left_value->set_origin(op_node);
+ scope->MarkUnused(left.value());
+ return Value();
+}
+
+// Plus/Minus -----------------------------------------------------------------
+
+Value ExecutePlus(Scope* scope,
+ const BinaryOpNode* op_node,
+ const Value& left,
+ const Value& right,
+ Err* err) {
+ Value ret = left;
+ ValuePlusEquals(scope, op_node, Token(), &ret, right, true, err);
+ ret.set_origin(op_node);
+ return ret;
+}
+
+Value ExecuteMinus(Scope* scope,
+ const BinaryOpNode* op_node,
+ const Value& left,
+ const Value& right,
+ Err* err) {
+ Value ret = left;
+ ValueMinusEquals(op_node, &ret, right, true, err);
+ ret.set_origin(op_node);
+ return ret;
+}
+
+// Comparison -----------------------------------------------------------------
+
+Value ExecuteEqualsEquals(Scope* scope,
+ const BinaryOpNode* op_node,
+ const Value& left,
+ const Value& right,
+ Err* err) {
+ if (left == right)
+ return Value(op_node, 1);
+ return Value(op_node, 0);
+}
+
+Value ExecuteNotEquals(Scope* scope,
+ const BinaryOpNode* op_node,
+ const Value& left,
+ const Value& right,
+ Err* err) {
+ // Evaluate in terms of ==.
+ Value result = ExecuteEqualsEquals(scope, op_node, left, right, err);
+ result.int_value() = static_cast<int64>(!result.int_value());
+ return result;
+}
+
+Value FillNeedsToIntegersError(const BinaryOpNode* op_node,
+ const Value& left,
+ const Value& right,
+ Err* err) {
+ *err = Err(op_node, "Comparison requires two integers.",
+ "This operator can only compare two integers.");
+ err->AppendRange(left.origin()->GetRange());
+ err->AppendRange(right.origin()->GetRange());
+ return Value();
+}
+
+Value ExecuteLessEquals(Scope* scope,
+ const BinaryOpNode* op_node,
+ const Value& left,
+ const Value& right,
+ Err* err) {
+ if (left.type() != Value::INTEGER || right.type() != Value::INTEGER)
+ return FillNeedsToIntegersError(op_node, left, right, err);
+ return Value(op_node, left.int_value() <= right.int_value());
+}
+
+Value ExecuteGreaterEquals(Scope* scope,
+ const BinaryOpNode* op_node,
+ const Value& left,
+ const Value& right,
+ Err* err) {
+ if (left.type() != Value::INTEGER || right.type() != Value::INTEGER)
+ return FillNeedsToIntegersError(op_node, left, right, err);
+ return Value(op_node, left.int_value() >= right.int_value());
+}
+
+Value ExecuteGreater(Scope* scope,
+ const BinaryOpNode* op_node,
+ const Value& left,
+ const Value& right,
+ Err* err) {
+ if (left.type() != Value::INTEGER || right.type() != Value::INTEGER)
+ return FillNeedsToIntegersError(op_node, left, right, err);
+ return Value(op_node, left.int_value() > right.int_value());
+}
+
+Value ExecuteLess(Scope* scope,
+ const BinaryOpNode* op_node,
+ const Value& left,
+ const Value& right,
+ Err* err) {
+ if (left.type() != Value::INTEGER || right.type() != Value::INTEGER)
+ return FillNeedsToIntegersError(op_node, left, right, err);
+ return Value(op_node, left.int_value() < right.int_value());
+}
+
+// Binary ----------------------------------------------------------------------
+
+Value ExecuteOr(Scope* scope,
+ const BinaryOpNode* op_node,
+ const Value& left,
+ const Value& right,
+ Err* err) {
+ return Value(op_node,
+ static_cast<int64>(left.InterpretAsInt() || right.InterpretAsInt()));
+}
+
+Value ExecuteAnd(Scope* scope,
+ const BinaryOpNode* op_node,
+ const Value& left,
+ const Value& right,
+ Err* err) {
+ return Value(op_node,
+ static_cast<int64>(left.InterpretAsInt() && right.InterpretAsInt()));
+}
+
+} // namespace
+
+// ----------------------------------------------------------------------------
+
+bool IsUnaryOperator(const Token& token) {
+ if (token.type() != Token::OPERATOR)
+ return false;
+ return token.value() == "!";
+}
+
+bool IsBinaryOperator(const Token& token) {
+ if (token.type() != Token::OPERATOR)
+ return false;
+ return token.value() == "=" ||
+ token.value() == "+=" ||
+ token.value() == "-=" ||
+ token.value() == "+" ||
+ token.value() == "-" ||
+ token.value() == "==" ||
+ token.value() == "!=" ||
+ token.value() == "<=" ||
+ token.value() == ">=" ||
+ token.value() == "<" ||
+ token.value() == ">" ||
+ token.value() == "&&" ||
+ token.value() == "||";
+}
+
+bool IsFunctionCallArgBeginScoper(const Token& token) {
+ return token.IsScoperEqualTo("(");
+}
+
+bool IsFunctionCallArgEndScoper(const Token& token) {
+ return token.IsScoperEqualTo(")");
+}
+
+bool IsScopeBeginScoper(const Token& token) {
+ return token.IsScoperEqualTo("{");
+}
+
+bool IsScopeEndScoper(const Token& token) {
+ return token.IsScoperEqualTo("}");
+}
+
+Value ExecuteUnaryOperator(Scope* scope,
+ const UnaryOpNode* op_node,
+ const Value& expr,
+ Err* err) {
+ DCHECK(op_node->op().IsOperatorEqualTo("!"));
+ return Value(op_node, !expr.InterpretAsInt());
+}
+
+Value ExecuteBinaryOperator(Scope* scope,
+ const BinaryOpNode* op_node,
+ const ParseNode* left,
+ const ParseNode* right,
+ Err* err) {
+ const Token& op = op_node->op();
+
+ // First handle the ones that take an lvalue.
+ if (op.IsOperatorEqualTo("=") ||
+ op.IsOperatorEqualTo("+=") ||
+ op.IsOperatorEqualTo("-=")) {
+ const IdentifierNode* left_id = left->AsIdentifier();
+ if (!left_id) {
+ *err = Err(op, "Operator requires an lvalue.",
+ "This thing on the left is not an idenfitier.");
+ err->AppendRange(left->GetRange());
+ return Value();
+ }
+ const Token& dest = left_id->value();
+
+ Value right_value = right->Execute(scope, err);
+ if (err->has_error())
+ return Value();
+ if (right_value.type() == Value::NONE) {
+ *err = Err(op, "Operator requires an rvalue.",
+ "This thing on the right does not evaluate to a value.");
+ err->AppendRange(right->GetRange());
+ return Value();
+ }
+
+ if (op.IsOperatorEqualTo("="))
+ return ExecuteEquals(scope, op_node, dest, right_value, err);
+ if (op.IsOperatorEqualTo("+="))
+ return ExecutePlusEquals(scope, op_node, dest, right_value, err);
+ if (op.IsOperatorEqualTo("-="))
+ return ExecuteMinusEquals(scope, op_node, dest, right_value, err);
+ NOTREACHED();
+ return Value();
+ }
+
+ // Left value.
+ Value left_value = left->Execute(scope, err);
+ if (err->has_error())
+ return Value();
+ if (left_value.type() == Value::NONE) {
+ *err = Err(op, "Operator requires an value.",
+ "This thing on the left does not evaluate to a value.");
+ err->AppendRange(left->GetRange());
+ return Value();
+ }
+
+ // Right value. Note: don't move this above to share code with the lvalue
+ // version since in this case we want to execute the left side first.
+ Value right_value = right->Execute(scope, err);
+ if (err->has_error())
+ return Value();
+ if (right_value.type() == Value::NONE) {
+ *err = Err(op, "Operator requires an value.",
+ "This thing on the right does not evaluate to a value.");
+ err->AppendRange(right->GetRange());
+ return Value();
+ }
+
+ // +, -.
+ if (op.IsOperatorEqualTo("-"))
+ return ExecuteMinus(scope, op_node, left_value, right_value, err);
+ if (op.IsOperatorEqualTo("+"))
+ return ExecutePlus(scope, op_node, left_value, right_value, err);
+
+ // Comparisons.
+ if (op.IsOperatorEqualTo("=="))
+ return ExecuteEqualsEquals(scope, op_node, left_value, right_value, err);
+ if (op.IsOperatorEqualTo("!="))
+ return ExecuteNotEquals(scope, op_node, left_value, right_value, err);
+ if (op.IsOperatorEqualTo(">="))
+ return ExecuteGreaterEquals(scope, op_node, left_value, right_value, err);
+ if (op.IsOperatorEqualTo("<="))
+ return ExecuteLessEquals(scope, op_node, left_value, right_value, err);
+ if (op.IsOperatorEqualTo(">"))
+ return ExecuteGreater(scope, op_node, left_value, right_value, err);
+ if (op.IsOperatorEqualTo("<"))
+ return ExecuteLess(scope, op_node, left_value, right_value, err);
+
+ // ||, &&.
+ if (op.IsOperatorEqualTo("||"))
+ return ExecuteOr(scope, op_node, left_value, right_value, err);
+ if (op.IsOperatorEqualTo("&&"))
+ return ExecuteAnd(scope, op_node, left_value, right_value, err);
+
+ return Value();
+}
diff --git a/tools/gn/operators.h b/tools/gn/operators.h
new file mode 100644
index 0000000..3401c22
--- /dev/null
+++ b/tools/gn/operators.h
@@ -0,0 +1,35 @@
+// 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_OPERATORS_H_
+#define TOOLS_GN_OPERATORS_H_
+
+class BinaryOpNode;
+class Err;
+class ParseNode;
+class Scope;
+class Token;
+class UnaryOpNode;
+class Value;
+
+bool IsUnaryOperator(const Token& token);
+bool IsBinaryOperator(const Token& token);
+
+bool IsFunctionCallArgBeginScoper(const Token& token); // "("
+bool IsFunctionCallArgEndScoper(const Token& token); // ")"
+
+bool IsScopeBeginScoper(const Token& token); // "{"
+bool IsScopeEndScoper(const Token& token); // "}"
+
+Value ExecuteUnaryOperator(Scope* scope,
+ const UnaryOpNode* op_node,
+ const Value& value,
+ Err* err);
+Value ExecuteBinaryOperator(Scope* scope,
+ const BinaryOpNode* op_node,
+ const ParseNode* left,
+ const ParseNode* right,
+ Err* err);
+
+#endif // TOOLS_GN_OPERATORS_H_
diff --git a/tools/gn/output_file.h b/tools/gn/output_file.h
new file mode 100644
index 0000000..9c5e4b2
--- /dev/null
+++ b/tools/gn/output_file.h
@@ -0,0 +1,41 @@
+// 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_OUTPUT_FILE_H_
+#define TOOLS_GN_OUTPUT_FILE_H_
+
+#include <string>
+
+#include "tools/gn/build_settings.h"
+#include "tools/gn/source_file.h"
+
+// A simple wrapper around a string that indicates the string is a path
+// relative to the output directory.
+class OutputFile {
+ public:
+ OutputFile() : value_() {}
+ explicit OutputFile(const base::StringPiece& str)
+ : value_(str.data(), str.size()) {
+ }
+
+ std::string& value() { return value_; }
+ const std::string& value() const { return value_; }
+
+ // Converts to a SourceFile by prepending the build directory to the file.
+ SourceFile GetSourceFile(const BuildSettings* build_settings) const {
+ return SourceFile(build_settings->build_dir().value() + value_);
+ }
+
+ bool operator==(const OutputFile& other) const {
+ return value_ == other.value_;
+ }
+ bool operator!=(const OutputFile& other) const {
+ return value_ != other.value_;
+ }
+
+ private:
+ std::string value_;
+};
+
+#endif
diff --git a/tools/gn/output_stream.h b/tools/gn/output_stream.h
new file mode 100644
index 0000000..6f39c86
--- /dev/null
+++ b/tools/gn/output_stream.h
@@ -0,0 +1,42 @@
+// 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_OUTPUT_STREAM_H_
+#define TOOLS_GN_OUTPUT_STREAM_H_
+
+class OutputStream {
+ public:
+
+
+
+ OutputStream& WriteBuffer(const char* buf, size_t len);
+ OutputStream& WriteInt(int i);
+
+ // Write a literal.
+ // This template expansion prevents having to look for nulls.
+ template<size_t size> OutputStream& Write(const char (&buf)[size]) {
+ return WriteBuffer(buf, size);
+ }
+
+ // Write a literal string.
+ OutputStream& Write(const std::string& str) {
+ return WriteBuffer(str.c_str(), str.size());
+ }
+
+ // Quotes if necessary, and does necessary escaping. If more than one
+ // input is provided, the results will be concatenated together (useful
+ // for constructing paths without a temporary buffer).
+ OutputStream& WritePath(const std::string& s);
+ OutputStream& WritePath(const std::string& s0,
+ const std::string& s1);
+ OutputStream& WritePath(const std::string& s0,
+ const std::string& s1,
+ const std::string& s2);
+
+ OutputStream& EndLine() {
+ return WriteBuffer("\n", 1);
+ }
+};
+
+#endif // TOOLS_GN_OUTPUT_STREAM_H_
diff --git a/tools/gn/parse_tree.cc b/tools/gn/parse_tree.cc
new file mode 100644
index 0000000..0f84970
--- /dev/null
+++ b/tools/gn/parse_tree.cc
@@ -0,0 +1,472 @@
+// 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/parse_tree.h"
+
+#include <string>
+
+#include "base/stl_util.h"
+#include "base/strings/string_number_conversions.h"
+#include "tools/gn/functions.h"
+#include "tools/gn/operators.h"
+#include "tools/gn/scope.h"
+#include "tools/gn/string_utils.h"
+
+namespace {
+
+std::string IndentFor(int value) {
+ std::string ret;
+ for (int i = 0; i < value; i++)
+ ret.append(" ");
+ return ret;
+}
+
+} // namespace
+
+ParseNode::ParseNode() {
+}
+
+ParseNode::~ParseNode() {
+}
+
+const AccessorNode* ParseNode::AsAccessor() const { return NULL; }
+const BinaryOpNode* ParseNode::AsBinaryOp() const { return NULL; }
+const BlockNode* ParseNode::AsBlock() const { return NULL; }
+const ConditionNode* ParseNode::AsConditionNode() const { return NULL; }
+const FunctionCallNode* ParseNode::AsFunctionCall() const { return NULL; }
+const IdentifierNode* ParseNode::AsIdentifier() const { return NULL; }
+const ListNode* ParseNode::AsList() const { return NULL; }
+const LiteralNode* ParseNode::AsLiteral() const { return NULL; }
+const UnaryOpNode* ParseNode::AsUnaryOp() const { return NULL; }
+
+// AccessorNode ---------------------------------------------------------------
+
+AccessorNode::AccessorNode() {
+}
+
+AccessorNode::~AccessorNode() {
+}
+
+const AccessorNode* AccessorNode::AsAccessor() const {
+ return this;
+}
+
+Value AccessorNode::Execute(Scope* scope, Err* err) const {
+ Value index_value = index_->Execute(scope, err);
+ if (err->has_error())
+ return Value();
+ if (!index_value.VerifyTypeIs(Value::INTEGER, err))
+ return Value();
+
+ const Value* base_value = scope->GetValue(base_.value(), true);
+ if (!base_value) {
+ *err = MakeErrorDescribing("Undefined identifier.");
+ return Value();
+ }
+ if (!base_value->VerifyTypeIs(Value::LIST, err))
+ return Value();
+
+ int64 index_int = index_value.int_value();
+ if (index_int < 0) {
+ *err = Err(index_->GetRange(), "Negative array subscript.",
+ "You gave me " + base::Int64ToString(index_int) + ".");
+ return Value();
+ }
+ size_t index_sizet = static_cast<size_t>(index_int);
+ if (index_sizet >= base_value->list_value().size()) {
+ *err = Err(index_->GetRange(), "Array subscript out of range.",
+ "You gave me " + base::Int64ToString(index_int) +
+ " but I was expecting something from 0 to " +
+ base::Int64ToString(
+ static_cast<int64>(base_value->list_value().size()) - 1) +
+ ", inclusive.");
+ return Value();
+ }
+
+ // Doing this assumes that there's no way in the language to do anything
+ // between the time the reference is created and the time that the reference
+ // is used. If there is, this will crash! Currently, this is just used for
+ // array accesses where this "shouldn't" happen.
+ return base_value->list_value()[index_sizet];
+}
+
+LocationRange AccessorNode::GetRange() const {
+ return LocationRange(base_.location(), index_->GetRange().end());
+}
+
+Err AccessorNode::MakeErrorDescribing(const std::string& msg,
+ const std::string& help) const {
+ return Err(GetRange(), msg, help);
+}
+
+void AccessorNode::Print(std::ostream& out, int indent) const {
+ out << IndentFor(indent) << "ACCESSOR\n";
+ out << IndentFor(indent + 1) << base_.value() << "\n";
+ index_->Print(out, indent + 1);
+}
+
+// BinaryOpNode ---------------------------------------------------------------
+
+BinaryOpNode::BinaryOpNode() {
+}
+
+BinaryOpNode::~BinaryOpNode() {
+}
+
+const BinaryOpNode* BinaryOpNode::AsBinaryOp() const {
+ return this;
+}
+
+Value BinaryOpNode::Execute(Scope* scope, Err* err) const {
+ return ExecuteBinaryOperator(scope, this, left_.get(), right_.get(), err);
+}
+
+LocationRange BinaryOpNode::GetRange() const {
+ return left_->GetRange().Union(right_->GetRange());
+}
+
+Err BinaryOpNode::MakeErrorDescribing(const std::string& msg,
+ const std::string& help) const {
+ return Err(op_, msg, help);
+}
+
+void BinaryOpNode::Print(std::ostream& out, int indent) const {
+ out << IndentFor(indent) << "BINARY(" << op_.value() << ")\n";
+ left_->Print(out, indent + 1);
+ right_->Print(out, indent + 1);
+}
+
+// BlockNode ------------------------------------------------------------------
+
+BlockNode::BlockNode(bool has_scope)
+ : has_scope_(has_scope),
+ begin_token_(NULL),
+ end_token_(NULL) {
+}
+
+BlockNode::~BlockNode() {
+ STLDeleteContainerPointers(statements_.begin(), statements_.end());
+}
+
+const BlockNode* BlockNode::AsBlock() const {
+ return this;
+}
+
+Value BlockNode::Execute(Scope* containing_scope, Err* err) const {
+ if (has_scope_) {
+ Scope our_scope(containing_scope);
+ Value ret = ExecuteBlockInScope(&our_scope, err);
+ if (err->has_error())
+ return Value();
+
+ // Check for unused vars in the scope.
+ //our_scope.CheckForUnusedVars(err);
+ return ret;
+ }
+ return ExecuteBlockInScope(containing_scope, err);
+}
+
+LocationRange BlockNode::GetRange() const {
+ if (begin_token_ && end_token_) {
+ return begin_token_->range().Union(end_token_->range());
+ }
+ return LocationRange(); // TODO(brettw) indicate the entire file somehow.
+}
+
+Err BlockNode::MakeErrorDescribing(const std::string& msg,
+ const std::string& help) const {
+ if (begin_token_)
+ return Err(*begin_token_, msg, help);
+ // TODO(brettw) this should have the beginning of the file in it or something.
+ return Err(Location(NULL, 1, 1), msg, help);
+}
+
+void BlockNode::Print(std::ostream& out, int indent) const {
+ out << IndentFor(indent) << "BLOCK\n";
+ for (size_t i = 0; i < statements_.size(); i++)
+ statements_[i]->Print(out, indent + 1);
+}
+
+Value BlockNode::ExecuteBlockInScope(Scope* our_scope, Err* err) const {
+ for (size_t i = 0; i < statements_.size() && !err->has_error(); i++) {
+ // Check for trying to execute things with no side effects in a block.
+ const ParseNode* cur = statements_[i];
+ if (cur->AsList() || cur->AsLiteral() || cur->AsUnaryOp() ||
+ cur->AsIdentifier()) {
+ *err = cur->MakeErrorDescribing(
+ "This statment has no effect.",
+ "Either delete it or do something with the result.");
+ return Value();
+ }
+ cur->Execute(our_scope, err);
+ }
+ return Value();
+}
+
+// ConditionNode --------------------------------------------------------------
+
+ConditionNode::ConditionNode() {
+}
+
+ConditionNode::~ConditionNode() {
+}
+
+const ConditionNode* ConditionNode::AsConditionNode() const {
+ return this;
+}
+
+Value ConditionNode::Execute(Scope* scope, Err* err) const {
+ Value condition_result = condition_->Execute(scope, err);
+ if (err->has_error())
+ return Value();
+ if (condition_result.type() == Value::NONE) {
+ *err = condition_->MakeErrorDescribing(
+ "This does not evaluate to a value.",
+ "Please give me something to work with for the if statement.");
+ err->AppendRange(if_token_.range());
+ return Value();
+ }
+
+ if (condition_result.InterpretAsInt()) {
+ if_true_->ExecuteBlockInScope(scope, err);
+ } else if (if_false_) {
+ // The else block is optional. It's either another condition (for an
+ // "else if" and we can just Execute it and the condition will handle
+ // the scoping) or it's a block indicating an "else" in which ase we
+ // need to be sure it inherits our scope.
+ const BlockNode* if_false_block = if_false_->AsBlock();
+ if (if_false_block)
+ if_false_block->ExecuteBlockInScope(scope, err);
+ else
+ if_false_->Execute(scope, err);
+ }
+
+ return Value();
+}
+
+LocationRange ConditionNode::GetRange() const {
+ if (if_false_)
+ return if_token_.range().Union(if_false_->GetRange());
+ return if_token_.range().Union(if_true_->GetRange());
+}
+
+Err ConditionNode::MakeErrorDescribing(const std::string& msg,
+ const std::string& help) const {
+ return Err(if_token_, msg, help);
+}
+
+void ConditionNode::Print(std::ostream& out, int indent) const {
+ out << IndentFor(indent) << "CONDITION\n";
+ condition_->Print(out, indent + 1);
+ if_true_->Print(out, indent + 1);
+ if (if_false_)
+ if_false_->Print(out, indent + 1);
+}
+
+// FunctionCallNode -----------------------------------------------------------
+
+FunctionCallNode::FunctionCallNode() {
+}
+
+FunctionCallNode::~FunctionCallNode() {
+}
+
+const FunctionCallNode* FunctionCallNode::AsFunctionCall() const {
+ return this;
+}
+
+Value FunctionCallNode::Execute(Scope* scope, Err* err) const {
+ Value args = args_->Execute(scope, err);
+ if (err->has_error())
+ return Value();
+ return ExecuteFunction(scope, this, args.list_value(), block_.get(), err);
+}
+
+LocationRange FunctionCallNode::GetRange() const {
+ if (block_)
+ return function_.range().Union(block_->GetRange());
+ return function_.range().Union(args_->GetRange());
+}
+
+Err FunctionCallNode::MakeErrorDescribing(const std::string& msg,
+ const std::string& help) const {
+ return Err(function_, msg, help);
+}
+
+void FunctionCallNode::Print(std::ostream& out, int indent) const {
+ out << IndentFor(indent) << "FUNCTION(" << function_.value() << ")\n";
+ args_->Print(out, indent + 1);
+ if (block_)
+ block_->Print(out, indent + 1);
+}
+
+// IdentifierNode --------------------------------------------------------------
+
+IdentifierNode::IdentifierNode() {
+}
+
+IdentifierNode::IdentifierNode(const Token& token) : value_(token) {
+}
+
+IdentifierNode::~IdentifierNode() {
+}
+
+const IdentifierNode* IdentifierNode::AsIdentifier() const {
+ return this;
+}
+
+Value IdentifierNode::Execute(Scope* scope, Err* err) const {
+ const Value* result = scope->GetValue(value_.value(), true);
+ if (!result) {
+ *err = MakeErrorDescribing("Undefined identifier");
+ return Value();
+ }
+ return *result;
+}
+
+LocationRange IdentifierNode::GetRange() const {
+ return value_.range();
+}
+
+Err IdentifierNode::MakeErrorDescribing(const std::string& msg,
+ const std::string& help) const {
+ return Err(value_, msg, help);
+}
+
+void IdentifierNode::Print(std::ostream& out, int indent) const {
+ out << IndentFor(indent) << "IDENTIFIER(" << value_.value() << ")\n";
+}
+
+// ListNode -------------------------------------------------------------------
+
+ListNode::ListNode() {
+}
+
+ListNode::~ListNode() {
+ STLDeleteContainerPointers(contents_.begin(), contents_.end());
+}
+
+const ListNode* ListNode::AsList() const {
+ return this;
+}
+
+Value ListNode::Execute(Scope* scope, Err* err) const {
+ Value result_value(this, Value::LIST);
+ std::vector<Value>& results = result_value.list_value();
+ results.resize(contents_.size());
+
+ for (size_t i = 0; i < contents_.size(); i++) {
+ const ParseNode* cur = contents_[i];
+ results[i] = cur->Execute(scope, err);
+ if (err->has_error())
+ return Value();
+ if (results[i].type() == Value::NONE) {
+ *err = cur->MakeErrorDescribing(
+ "This does not evaluate to a value.",
+ "I can't do something with nothing.");
+ return Value();
+ }
+ }
+ return result_value;
+}
+
+LocationRange ListNode::GetRange() const {
+ return LocationRange(begin_token_.location(), end_token_.location());
+}
+
+Err ListNode::MakeErrorDescribing(const std::string& msg,
+ const std::string& help) const {
+ return Err(begin_token_, msg, help);
+}
+
+void ListNode::Print(std::ostream& out, int indent) const {
+ out << IndentFor(indent) << "LIST\n";
+ for (size_t i = 0; i < contents_.size(); i++)
+ contents_[i]->Print(out, indent + 1);
+}
+
+// LiteralNode -----------------------------------------------------------------
+
+LiteralNode::LiteralNode() {
+}
+
+LiteralNode::LiteralNode(const Token& token) : value_(token) {
+}
+
+LiteralNode::~LiteralNode() {
+}
+
+const LiteralNode* LiteralNode::AsLiteral() const {
+ return this;
+}
+
+Value LiteralNode::Execute(Scope* scope, Err* err) const {
+ switch (value_.type()) {
+ case Token::INTEGER: {
+ int64 result_int;
+ if (!base::StringToInt64(value_.value(), &result_int)) {
+ *err = MakeErrorDescribing("This does not look like an integer");
+ return Value();
+ }
+ return Value(this, result_int);
+ }
+ case Token::STRING: {
+ // TODO(brettw) Unescaping probably needs to be moved & improved.
+ // The input value includes the quotes around the string, strip those
+ // off and unescape.
+ Value v(this, Value::STRING);
+ ExpandStringLiteral(scope, value_, &v, err);
+ return v;
+ }
+ default:
+ NOTREACHED();
+ return Value();
+ }
+}
+
+LocationRange LiteralNode::GetRange() const {
+ return value_.range();
+}
+
+Err LiteralNode::MakeErrorDescribing(const std::string& msg,
+ const std::string& help) const {
+ return Err(value_, msg, help);
+}
+
+void LiteralNode::Print(std::ostream& out, int indent) const {
+ out << IndentFor(indent) << "LITERAL(" << value_.value() << ")\n";
+}
+
+// UnaryOpNode ----------------------------------------------------------------
+
+UnaryOpNode::UnaryOpNode() {
+}
+
+UnaryOpNode::~UnaryOpNode() {
+}
+
+const UnaryOpNode* UnaryOpNode::AsUnaryOp() const {
+ return this;
+}
+
+Value UnaryOpNode::Execute(Scope* scope, Err* err) const {
+ Value operand_value = operand_->Execute(scope, err);
+ if (err->has_error())
+ return Value();
+ return ExecuteUnaryOperator(scope, this, operand_value, err);
+}
+
+LocationRange UnaryOpNode::GetRange() const {
+ return op_.range().Union(operand_->GetRange());
+}
+
+Err UnaryOpNode::MakeErrorDescribing(const std::string& msg,
+ const std::string& help) const {
+ return Err(op_, msg, help);
+}
+
+void UnaryOpNode::Print(std::ostream& out, int indent) const {
+ out << IndentFor(indent) << "UNARY(" << op_.value() << ")\n";
+ operand_->Print(out, indent + 1);
+}
diff --git a/tools/gn/parse_tree.h b/tools/gn/parse_tree.h
new file mode 100644
index 0000000..09646e5
--- /dev/null
+++ b/tools/gn/parse_tree.h
@@ -0,0 +1,366 @@
+// 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_PARSE_TREE_H_
+#define TOOLS_GN_PARSE_TREE_H_
+
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "base/memory/scoped_ptr.h"
+#include "tools/gn/err.h"
+#include "tools/gn/token.h"
+#include "tools/gn/value.h"
+
+class AccessorNode;
+class BinaryOpNode;
+class BlockNode;
+class ConditionNode;
+class FunctionCallNode;
+class IdentifierNode;
+class ListNode;
+class LiteralNode;
+class Scope;
+class UnaryOpNode;
+
+// ParseNode -------------------------------------------------------------------
+
+// A node in the AST.
+class ParseNode {
+ public:
+ ParseNode();
+ virtual ~ParseNode();
+
+ virtual const AccessorNode* AsAccessor() const;
+ virtual const BinaryOpNode* AsBinaryOp() const;
+ virtual const BlockNode* AsBlock() const;
+ virtual const ConditionNode* AsConditionNode() const;
+ virtual const FunctionCallNode* AsFunctionCall() const;
+ virtual const IdentifierNode* AsIdentifier() const;
+ virtual const ListNode* AsList() const;
+ virtual const LiteralNode* AsLiteral() const;
+ virtual const UnaryOpNode* AsUnaryOp() const;
+
+ virtual Value Execute(Scope* scope, Err* err) const = 0;
+
+ virtual LocationRange GetRange() const = 0;
+
+ // Returns an error with the given messages and the range set to something
+ // that indicates this node.
+ virtual Err MakeErrorDescribing(
+ const std::string& msg,
+ const std::string& help = std::string()) const = 0;
+
+ // Prints a representation of this node to the given string, indenting
+ // by the given number of spaces.
+ virtual void Print(std::ostream& out, int indent) const = 0;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(ParseNode);
+};
+
+// AccessorNode ----------------------------------------------------------------
+
+// Access an array element.
+//
+// If we need to add support for member variables like "variable.len" I was
+// thinking this would also handle that case.
+class AccessorNode : public ParseNode {
+ public:
+ AccessorNode();
+ virtual ~AccessorNode();
+
+ virtual const AccessorNode* AsAccessor() const OVERRIDE;
+ virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
+ virtual LocationRange GetRange() const OVERRIDE;
+ virtual Err MakeErrorDescribing(
+ const std::string& msg,
+ const std::string& help = std::string()) const OVERRIDE;
+ virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+
+ // Base is the thing on the left of the [], currently always required to be
+ // an identifier token.
+ const Token& base() const { return base_; }
+ void set_base(const Token& b) { base_ = b; }
+
+ // Index is the expression inside the [].
+ const ParseNode* index() const { return index_.get(); }
+ void set_index(scoped_ptr<ParseNode> i) { index_ = i.Pass(); }
+
+ private:
+ Token base_;
+ scoped_ptr<ParseNode> index_;
+
+ DISALLOW_COPY_AND_ASSIGN(AccessorNode);
+};
+
+// BinaryOpNode ----------------------------------------------------------------
+
+class BinaryOpNode : public ParseNode {
+ public:
+ BinaryOpNode();
+ virtual ~BinaryOpNode();
+
+ virtual const BinaryOpNode* AsBinaryOp() const OVERRIDE;
+ virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
+ virtual LocationRange GetRange() const OVERRIDE;
+ virtual Err MakeErrorDescribing(
+ const std::string& msg,
+ const std::string& help = std::string()) const OVERRIDE;
+ virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+
+ const Token& op() const { return op_; }
+ void set_op(const Token& t) { op_ = t; }
+
+ const ParseNode* left() const { return left_.get(); }
+ void set_left(scoped_ptr<ParseNode> left) {
+ left_ = left.Pass();
+ }
+
+ const ParseNode* right() const { return right_.get(); }
+ void set_right(scoped_ptr<ParseNode> right) {
+ right_ = right.Pass();
+ }
+
+ private:
+ scoped_ptr<ParseNode> left_;
+ Token op_;
+ scoped_ptr<ParseNode> right_;
+
+ DISALLOW_COPY_AND_ASSIGN(BinaryOpNode);
+};
+
+// BlockNode -------------------------------------------------------------------
+
+class BlockNode : public ParseNode {
+ public:
+ // Set has_scope if this block introduces a nested scope.
+ BlockNode(bool has_scope);
+ virtual ~BlockNode();
+
+ virtual const BlockNode* AsBlock() const OVERRIDE;
+ virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
+ virtual LocationRange GetRange() const OVERRIDE;
+ virtual Err MakeErrorDescribing(
+ const std::string& msg,
+ const std::string& help = std::string()) const OVERRIDE;
+ virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+
+ void set_begin_token(const Token* t) { begin_token_ = t; }
+ void set_end_token(const Token* t) { end_token_ = t; }
+
+ const std::vector<ParseNode*>& statements() const { return statements_; }
+ void append_statement(scoped_ptr<ParseNode> s) {
+ statements_.push_back(s.release());
+ }
+
+ // Doesn't create a nested scope.
+ Value ExecuteBlockInScope(Scope* our_scope, Err* err) const;
+
+ private:
+ bool has_scope_;
+
+ // Tokens corresponding to { and }, if any (may be NULL).
+ const Token* begin_token_;
+ const Token* end_token_;
+
+ // Owning pointers, use unique_ptr when we can use C++11.
+ std::vector<ParseNode*> statements_;
+
+ DISALLOW_COPY_AND_ASSIGN(BlockNode);
+};
+
+// ConditionNode ---------------------------------------------------------------
+
+class ConditionNode : public ParseNode {
+ public:
+ ConditionNode();
+ virtual ~ConditionNode();
+
+ virtual const ConditionNode* AsConditionNode() const OVERRIDE;
+ virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
+ virtual LocationRange GetRange() const OVERRIDE;
+ virtual Err MakeErrorDescribing(
+ const std::string& msg,
+ const std::string& help = std::string()) const OVERRIDE;
+ virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+
+ void set_if_token(const Token& token) { if_token_ = token; }
+
+ const ParseNode* condition() const { return condition_.get(); }
+ void set_condition(scoped_ptr<ParseNode> c) {
+ condition_ = c.Pass();
+ }
+
+ const BlockNode* if_true() const { return if_true_.get(); }
+ void set_if_true(scoped_ptr<BlockNode> t) {
+ if_true_ = t.Pass();
+ }
+
+ // This is either empty, a block (for the else clause), or another
+ // condition.
+ const ParseNode* if_false() const { return if_false_.get(); }
+ void set_if_false(scoped_ptr<ParseNode> f) {
+ if_false_ = f.Pass();
+ }
+
+ private:
+ // Token corresponding to the "if" string.
+ Token if_token_;
+
+ scoped_ptr<ParseNode> condition_; // Always non-null.
+ scoped_ptr<BlockNode> if_true_; // Always non-null.
+ scoped_ptr<ParseNode> if_false_; // May be null.
+
+ DISALLOW_COPY_AND_ASSIGN(ConditionNode);
+};
+
+// FunctionCallNode ------------------------------------------------------------
+
+class FunctionCallNode : public ParseNode {
+ public:
+ FunctionCallNode();
+ virtual ~FunctionCallNode();
+
+ virtual const FunctionCallNode* AsFunctionCall() const OVERRIDE;
+ virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
+ virtual LocationRange GetRange() const OVERRIDE;
+ virtual Err MakeErrorDescribing(
+ const std::string& msg,
+ const std::string& help = std::string()) const OVERRIDE;
+ virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+
+ const Token& function() const { return function_; }
+ void set_function(Token t) { function_ = t; }
+
+ const ListNode* args() const { return args_.get(); }
+ void set_args(scoped_ptr<ListNode> a) { args_ = a.Pass(); }
+
+ const BlockNode* block() const { return block_.get(); }
+ void set_block(scoped_ptr<BlockNode> b) { block_ = b.Pass(); }
+
+ private:
+ Token function_;
+ scoped_ptr<ListNode> args_;
+ scoped_ptr<BlockNode> block_; // May be null.
+
+ DISALLOW_COPY_AND_ASSIGN(FunctionCallNode);
+};
+
+// IdentifierNode --------------------------------------------------------------
+
+class IdentifierNode : public ParseNode {
+ public:
+ IdentifierNode();
+ IdentifierNode(const Token& token);
+ virtual ~IdentifierNode();
+
+ virtual const IdentifierNode* AsIdentifier() const OVERRIDE;
+ virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
+ virtual LocationRange GetRange() const OVERRIDE;
+ virtual Err MakeErrorDescribing(
+ const std::string& msg,
+ const std::string& help = std::string()) const OVERRIDE;
+ virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+
+ const Token& value() const { return value_; }
+ void set_value(const Token& t) { value_ = t; }
+
+ private:
+ Token value_;
+
+ DISALLOW_COPY_AND_ASSIGN(IdentifierNode);
+};
+
+// ListNode --------------------------------------------------------------------
+
+class ListNode : public ParseNode {
+ public:
+ ListNode();
+ virtual ~ListNode();
+
+ virtual const ListNode* AsList() const OVERRIDE;
+ virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
+ virtual LocationRange GetRange() const OVERRIDE;
+ virtual Err MakeErrorDescribing(
+ const std::string& msg,
+ const std::string& help = std::string()) const OVERRIDE;
+ virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+
+ void set_begin_token(const Token& t) { begin_token_ = t; }
+ void set_end_token(const Token& t) { end_token_ = t; }
+
+ void append_item(scoped_ptr<ParseNode> s) {
+ contents_.push_back(s.release());
+ }
+ const std::vector<ParseNode*>& contents() const { return contents_; }
+
+ private:
+ // Tokens corresponding to the [ and ].
+ Token begin_token_;
+ Token end_token_;
+
+ // Owning pointers, use unique_ptr when we can use C++11.
+ std::vector<ParseNode*> contents_;
+
+ DISALLOW_COPY_AND_ASSIGN(ListNode);
+};
+
+// LiteralNode -----------------------------------------------------------------
+
+class LiteralNode : public ParseNode {
+ public:
+ LiteralNode();
+ LiteralNode(const Token& token);
+ virtual ~LiteralNode();
+
+ virtual const LiteralNode* AsLiteral() const OVERRIDE;
+ virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
+ virtual LocationRange GetRange() const OVERRIDE;
+ virtual Err MakeErrorDescribing(
+ const std::string& msg,
+ const std::string& help = std::string()) const OVERRIDE;
+ virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+
+ const Token& value() const { return value_; }
+ void set_value(const Token& t) { value_ = t; }
+
+ private:
+ Token value_;
+
+ DISALLOW_COPY_AND_ASSIGN(LiteralNode);
+};
+
+// UnaryOpNode -----------------------------------------------------------------
+
+class UnaryOpNode : public ParseNode {
+ public:
+ UnaryOpNode();
+ virtual ~UnaryOpNode();
+
+ virtual const UnaryOpNode* AsUnaryOp() const OVERRIDE;
+ virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
+ virtual LocationRange GetRange() const OVERRIDE;
+ virtual Err MakeErrorDescribing(
+ const std::string& msg,
+ const std::string& help = std::string()) const OVERRIDE;
+ virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+
+ const Token& op() const { return op_; }
+ void set_op(const Token& t) { op_ = t; }
+
+ const ParseNode* operand() const { return operand_.get(); }
+ void set_operand(scoped_ptr<ParseNode> operand) {
+ operand_ = operand.Pass();
+ }
+
+ private:
+ Token op_;
+ scoped_ptr<ParseNode> operand_;
+
+ DISALLOW_COPY_AND_ASSIGN(UnaryOpNode);
+};
+
+#endif // TOOLS_GN_PARSE_TREE_H_
diff --git a/tools/gn/parser.cc b/tools/gn/parser.cc
new file mode 100644
index 0000000..385aa34
--- /dev/null
+++ b/tools/gn/parser.cc
@@ -0,0 +1,470 @@
+// 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/parser.h"
+
+#include "base/logging.h"
+#include "tools/gn/functions.h"
+#include "tools/gn/operators.h"
+#include "tools/gn/token.h"
+
+namespace {
+
+// Returns true if the two tokens are on the same line. We assume they're in
+// the same file.
+bool IsSameLine(const Token& a, const Token& b) {
+ DCHECK(a.location().file() == b.location().file());
+ return a.location().line_number() == b.location().line_number();
+}
+
+} // namespace
+
+Parser::Parser(const std::vector<Token>& tokens, Err* err)
+ : tokens_(tokens),
+ err_(err),
+ cur_(0) {
+}
+
+Parser::~Parser() {
+}
+
+// static
+scoped_ptr<ParseNode> Parser::Parse(const std::vector<Token>& tokens,
+ Err* err) {
+ Parser p(tokens, err);
+ return p.ParseBlock(false).PassAs<ParseNode>();
+}
+
+// static
+scoped_ptr<ParseNode> Parser::ParseExpression(const std::vector<Token>& tokens,
+ Err* err) {
+ Parser p(tokens, err);
+ return p.ParseExpression().Pass();
+}
+
+bool Parser::IsToken(Token::Type type, char* str) const {
+ if (at_end())
+ return false;
+ return cur_token().type() == type || cur_token().value() == str;
+}
+
+scoped_ptr<AccessorNode> Parser::ParseAccessor() {
+ scoped_ptr<AccessorNode> accessor(new AccessorNode);
+
+ DCHECK(cur_token().type() == Token::IDENTIFIER);
+ accessor->set_base(cur_token());
+ cur_++; // Skip identifier.
+ cur_++; // Skip "[" (we know this exists because the existance of this
+ // token is how the caller knows it's an accessor.
+
+ if (at_end()) {
+ *err_ = MakeEOFError("Got EOF when looking for list index.");
+ return scoped_ptr<AccessorNode>();
+ }
+
+ // Get the expression.
+ scoped_ptr<ParseNode> expr = ParseExpression().Pass();
+ if (has_error())
+ return scoped_ptr<AccessorNode>();
+ if (at_end()) {
+ *err_ = MakeEOFError("Got EOF when looking for list accessor ]");
+ return scoped_ptr<AccessorNode>();
+ }
+ accessor->set_index(expr.Pass());
+
+ // Skip over "]"
+ if (!cur_token().IsScoperEqualTo("]")) {
+ *err_ = Err(cur_token(), "Expecting ]",
+ "You started a list access but didn't terminate it, and instead "
+ "I fould this\nstupid thing.");
+ return scoped_ptr<AccessorNode>();
+ }
+ cur_++;
+
+ return accessor.Pass();
+}
+
+// Blocks at the file scope don't need {} so we have the option to ignore
+// them. When need_braces is set, we'll expect a begin an end brace.
+//
+// block := "{" block_contents "}"
+// block_contents := (expression | conditional | block)*
+scoped_ptr<BlockNode> Parser::ParseBlock(bool need_braces) {
+ scoped_ptr<BlockNode> block(new BlockNode(true));
+
+ // Eat initial { if necessary.
+ const Token* opening_curly_brace;
+ if (need_braces) {
+ if (at_end()) {
+ *err_ = MakeEOFError("Got EOF when looking for { for block.",
+ "It should have been after here.");
+ return scoped_ptr<BlockNode>();
+ } else if(!IsScopeBeginScoper(cur_token())) {
+ *err_ = Err(cur_token(), "Expecting { instead of this thing.",
+ "THOU SHALT USE CURLY BRACES FOR ALL BLOCKS.");
+ return scoped_ptr<BlockNode>();
+ }
+ opening_curly_brace = &cur_token();
+ block->set_begin_token(opening_curly_brace);
+ cur_++;
+ }
+
+ // Loop until EOF or end brace found.
+ while (!at_end() && !IsScopeEndScoper(cur_token())) {
+ if (cur_token().IsIdentifierEqualTo("if")) {
+ // Conditional.
+ block->append_statement(ParseCondition().PassAs<ParseNode>());
+ } else if (IsScopeBeginScoper(cur_token())) {
+ // Nested block.
+ block->append_statement(ParseBlock(true).PassAs<ParseNode>());
+ } else {
+ // Everything else is an expression.
+ block->append_statement(ParseExpression().PassAs<ParseNode>());
+ }
+ if (has_error())
+ return scoped_ptr<BlockNode>();
+ }
+
+ // Eat the ending "}" if necessary.
+ if (need_braces) {
+ if (at_end() || !IsScopeEndScoper(cur_token())) {
+ *err_ = Err(*opening_curly_brace, "Expecting }",
+ "I ran headlong into the end of the file looking for the "
+ "closing brace\ncorresponding to this one.");
+ return scoped_ptr<BlockNode>();
+ }
+ block->set_end_token(&cur_token());
+ cur_++; // Skip past "}".
+ }
+
+ return block.Pass();
+}
+
+// conditional := "if (" expression ")" block [else_conditional]
+// else_conditional := ("else" block) | ("else" conditional)
+scoped_ptr<ConditionNode> Parser::ParseCondition() {
+ scoped_ptr<ConditionNode> cond(new ConditionNode);
+
+ // Skip past "if".
+ const Token& if_token = cur_token();
+ cond->set_if_token(if_token);
+ DCHECK(if_token.IsIdentifierEqualTo("if"));
+ cur_++;
+
+ if (at_end() || !IsFunctionCallArgBeginScoper(cur_token())) {
+ *err_ = Err(if_token, "Expecting \"(\" after \"if\"",
+ "Did you think this was Python or something?");
+ return scoped_ptr<ConditionNode>();
+ }
+
+ // Skip over (.
+ const Token& open_paren_token = cur_token();
+ cur_++;
+ if (at_end()) {
+ *err_ = Err(if_token, "Unexpected EOF inside if condition");
+ return scoped_ptr<ConditionNode>();
+ }
+
+ // Condition inside ().
+ cond->set_condition(ParseExpression().Pass());
+ if (has_error())
+ return scoped_ptr<ConditionNode>();
+
+ if (at_end() || !IsFunctionCallArgEndScoper(cur_token())) {
+ *err_ = Err(open_paren_token, "Expecting \")\" for \"if\" condition",
+ "You didn't finish the thought you started here.");
+ return scoped_ptr<ConditionNode>();
+ }
+ cur_++; // Skip over )
+
+ // Contents of {}.
+ cond->set_if_true(ParseBlock(true).Pass());
+ if (has_error())
+ return scoped_ptr<ConditionNode>();
+
+ // Optional "else" at the end.
+ if (!at_end() && cur_token().IsIdentifierEqualTo("else")) {
+ cur_++;
+
+ // The else may be followed by an if or a block.
+ if (at_end()) {
+ *err_ = MakeEOFError("Ran into end of file after \"else\".",
+ "else, WHAT?!?!?");
+ return scoped_ptr<ConditionNode>();
+ }
+ if (cur_token().IsIdentifierEqualTo("if")) {
+ // "else if() {"
+ cond->set_if_false(ParseCondition().PassAs<ParseNode>());
+ } else if (IsScopeBeginScoper(cur_token())) {
+ // "else {"
+ cond->set_if_false(ParseBlock(true).PassAs<ParseNode>());
+ } else {
+ // else <anything else>
+ *err_ = Err(cur_token(), "Expected \"if\" or \"{\" after \"else\".",
+ "This is neither of those things.");
+ return scoped_ptr<ConditionNode>();
+ }
+ }
+
+ if (has_error())
+ return scoped_ptr<ConditionNode>();
+ return cond.Pass();
+}
+
+// expression := paren_expression | accessor | identifier | literal |
+// funccall | unary_expression | binary_expression
+//
+// accessor := identifier <non-newline-whitespace>* "[" expression "]"
+//
+// The "non-newline-whitespace is used to differentiate between this case:
+// a[1]
+// and this one:
+// a
+// [1]
+// The second one is kind of stupid (since it does nothing with the values)
+// but is still legal.
+scoped_ptr<ParseNode> Parser::ParseExpression() {
+ scoped_ptr<ParseNode> expr = ParseExpressionExceptBinaryOperators();
+ if (has_error())
+ return scoped_ptr<ParseNode>();
+
+ // That may have hit EOF, in which case we can't have any binary operators.
+ if (at_end())
+ return expr.Pass();
+
+ // TODO(brettw) handle operator precidence!
+ // Gobble up all subsequent expressions as long as there are binary
+ // operators.
+
+ if (IsBinaryOperator(cur_token())) {
+ scoped_ptr<BinaryOpNode> binary_op(new BinaryOpNode);
+ binary_op->set_left(expr.Pass());
+ const Token& operator_token = cur_token();
+ binary_op->set_op(operator_token);
+ cur_++;
+ if (at_end()) {
+ *err_ = Err(operator_token, "Unexpected EOF in expression.",
+ "I was looking for the right-hand-side of this operator.");
+ return scoped_ptr<ParseNode>();
+ }
+ binary_op->set_right(ParseExpression().Pass());
+ if (has_error())
+ return scoped_ptr<ParseNode>();
+ return binary_op.PassAs<ParseNode>();
+ }
+
+ return expr.Pass();
+}
+
+
+// This internal one does not handle binary operators, since it requires
+// looking at the "next" thing. The regular ParseExpression above handles it.
+scoped_ptr<ParseNode> Parser::ParseExpressionExceptBinaryOperators() {
+ if (at_end())
+ return scoped_ptr<ParseNode>();
+
+ const Token& token = cur_token();
+
+ // Unary expression.
+ if (IsUnaryOperator(token))
+ return ParseUnaryOp().PassAs<ParseNode>();
+
+ // Parenthesized expressions.
+ if (token.IsScoperEqualTo("("))
+ return ParseParenExpression();
+
+ // Function calls.
+ if (token.type() == Token::IDENTIFIER) {
+ if (has_next_token() && IsFunctionCallArgBeginScoper(next_token()))
+ return ParseFunctionCall().PassAs<ParseNode>();
+ }
+
+ // Lists.
+ if (token.IsScoperEqualTo("[")) {
+ return ParseList(Token(Location(), Token::SCOPER, "["),
+ Token(Location(), Token::SCOPER, "]")).PassAs<ParseNode>();
+ }
+
+ // Literals.
+ if (token.type() == Token::STRING || token.type() == Token::INTEGER) {
+ cur_++;
+ return scoped_ptr<ParseNode>(new LiteralNode(token));
+ }
+
+ // Accessors.
+ if (token.type() == Token::IDENTIFIER &&
+ has_next_token() && next_token().IsScoperEqualTo("[") &&
+ IsSameLine(token, next_token())) {
+ return ParseAccessor().PassAs<ParseNode>();
+ }
+
+ // Identifiers.
+ if (token.type() == Token::IDENTIFIER) {
+ cur_++;
+ return scoped_ptr<ParseNode>(new IdentifierNode(token));
+ }
+
+ // Handle errors.
+ if (token.type() == Token::SEPARATOR) {
+ *err_ = Err(token, "Unexpected comma.",
+ "You can't put a comma here, it must be in list separating "
+ "complete\nthoughts.");
+ } else if (IsScopeBeginScoper(token)) {
+ *err_ = Err(token, "Unexpected token.",
+ "You can't put a \"{\" scope here, it must be in a block.");
+ } else {
+ *err_ = Err(token, "Unexpected token.",
+ "I was really hoping for something else here and you let me down.");
+ }
+ return scoped_ptr<ParseNode>();
+}
+
+// function_call := identifier "(" list_contents ")"
+// [<non-newline-whitespace>* block]
+scoped_ptr<FunctionCallNode> Parser::ParseFunctionCall() {
+ scoped_ptr<FunctionCallNode> func(new FunctionCallNode);
+
+ const Token& function_token = cur_token();
+ func->set_function(function_token);
+
+ // This function should only get called when we know we have a function,
+ // which only happens when there is a paren following the name. Skip past it.
+ DCHECK(has_next_token());
+ cur_++; // Skip past function name to (.
+ const Token& open_paren_token = cur_token();
+ DCHECK(IsFunctionCallArgBeginScoper(open_paren_token));
+
+ if (at_end()) {
+ *err_ = Err(open_paren_token, "Unexpected EOF for function call.",
+ "You didn't finish the thought you started here.");
+ return scoped_ptr<FunctionCallNode>();
+ }
+
+ // Arguments.
+ func->set_args(ParseList(Token(Location(), Token::SCOPER, "("),
+ Token(Location(), Token::SCOPER, ")")));
+ if (has_error())
+ return scoped_ptr<FunctionCallNode>();
+
+ // Optional {} after function call for certain functions. The "{" must be on
+ // the same line as the ")" to disambiguate the case of a function followed
+ // by a random block just used for scoping purposes.
+ if (!at_end() && IsScopeBeginScoper(cur_token())) {
+ const Token& args_end_token = tokens_[cur_ - 1];
+ DCHECK(args_end_token.IsScoperEqualTo(")"));
+ if (IsSameLine(args_end_token, cur_token()))
+ func->set_block(ParseBlock(true).Pass());
+ }
+
+ if (has_error())
+ return scoped_ptr<FunctionCallNode>();
+ return func.Pass();
+}
+
+// list := "[" expression* "]"
+// list_contents := [(expression ",")* expression [","]]
+//
+// The list_contents is also used in function calls surrounded by parens, so
+// this function takes the tokens that are expected to surround the list.
+scoped_ptr<ListNode> Parser::ParseList(const Token& expected_begin,
+ const Token& expected_end) {
+ scoped_ptr<ListNode> list(new ListNode);
+
+ const Token& open_bracket_token = cur_token();
+ list->set_begin_token(open_bracket_token);
+ cur_++; // Skip "[" or "(".
+
+ bool need_separator = false;
+ while(true) {
+ if (at_end()) {
+ *err_ = Err(open_bracket_token, "EOF found when parsing list.",
+ "I expected a \"" + expected_end.value().as_string() +
+ "\" corresponding to this one.");
+ return scoped_ptr<ListNode>();
+ }
+ if (cur_token().type() == expected_end.type() &&
+ cur_token().value() == expected_end.value()) {
+ list->set_end_token(cur_token());
+ cur_++;
+ break;
+ }
+
+ if (need_separator) {
+ DCHECK(!list->contents().empty());
+ LocationRange prev_item_range =
+ list->contents().at(list->contents().size() - 1)->GetRange();
+ *err_ = Err(prev_item_range.end(),
+ "Need comma separating items in list.",
+ "You probably need a comma after this thingy.");
+ err_->AppendRange(prev_item_range);
+ return scoped_ptr<ListNode>();
+ }
+ scoped_ptr<ParseNode> expr = ParseExpression().Pass();
+ if (has_error())
+ return scoped_ptr<ListNode>();
+ list->append_item(expr.Pass());
+
+ need_separator = true;
+ if (!at_end()) {
+ // Skip over the separator, marking that we found it.
+ if (cur_token().type() == Token::SEPARATOR) {
+ cur_++;
+ need_separator = false;
+ }
+ }
+ }
+ return list.Pass();
+}
+
+// paren_expression := "(" expression ")"
+scoped_ptr<ParseNode> Parser::ParseParenExpression() {
+ const Token& open_paren_token = cur_token();
+ cur_++; // Skip over (
+
+ scoped_ptr<ParseNode> ret = ParseExpression();
+ if (has_error())
+ return scoped_ptr<ParseNode>();
+
+ if (at_end()) {
+ *err_ = Err(open_paren_token, "EOF found when parsing expression.",
+ "I was looking for a \")\" corresponding to this one.");
+ return scoped_ptr<ParseNode>();
+ }
+ if (!cur_token().IsScoperEqualTo(")")) {
+ *err_ = Err(open_paren_token, "Expected \")\" for expression",
+ "I was looking for a \")\" corresponding to this one.");
+ return scoped_ptr<ParseNode>();
+ }
+ cur_++; // Skip over )
+ return ret.Pass();
+}
+
+// unary_expression := "!" expression
+scoped_ptr<UnaryOpNode> Parser::ParseUnaryOp() {
+ scoped_ptr<UnaryOpNode> unary(new UnaryOpNode);
+
+ DCHECK(!at_end() && IsUnaryOperator(cur_token()));
+ const Token& op_token = cur_token();
+ unary->set_op(op_token);
+ cur_++;
+
+ if (at_end()) {
+ *err_ = Err(op_token, "Expected expression.",
+ "This operator needs something to operate on.");
+ return scoped_ptr<UnaryOpNode>();
+ }
+ unary->set_operand(ParseExpression().Pass());
+ if (has_error())
+ return scoped_ptr<UnaryOpNode>();
+ return unary.Pass();
+}
+
+Err Parser::MakeEOFError(const std::string& message,
+ const std::string& help) const {
+ if (tokens_.empty())
+ return Err(Location(NULL, 1, 1), message, help);
+
+ const Token& last = tokens_[tokens_.size() - 1];
+ return Err(last, message, help);
+}
diff --git a/tools/gn/parser.h b/tools/gn/parser.h
new file mode 100644
index 0000000..252b801
--- /dev/null
+++ b/tools/gn/parser.h
@@ -0,0 +1,81 @@
+// 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_PARSER_H_
+#define TOOLS_GN_PARSER_H_
+
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/gtest_prod_util.h"
+#include "base/memory/scoped_ptr.h"
+#include "tools/gn/err.h"
+#include "tools/gn/parse_tree.h"
+
+// Parses a series of tokens. The resulting AST will refer to the tokens passed
+// to the input, so the tokens an the file data they refer to must outlive your
+// use of the ParseNode.
+class Parser {
+ public:
+ // Will return a null pointer and set the err on error.
+ static scoped_ptr<ParseNode> Parse(const std::vector<Token>& tokens,
+ Err* err);
+
+ // Alternative to parsing that assumes the input is an expression.
+ static scoped_ptr<ParseNode> ParseExpression(const std::vector<Token>& tokens,
+ Err* err);
+
+ private:
+ // Vector must be valid for lifetime of call.
+ Parser(const std::vector<Token>& tokens, Err* err);
+ ~Parser();
+
+ scoped_ptr<AccessorNode> ParseAccessor();
+ scoped_ptr<BlockNode> ParseBlock(bool need_braces);
+ scoped_ptr<ConditionNode> ParseCondition();
+ scoped_ptr<ParseNode> ParseExpression();
+ scoped_ptr<ParseNode> ParseExpressionExceptBinaryOperators();
+ scoped_ptr<FunctionCallNode> ParseFunctionCall();
+ scoped_ptr<ListNode> ParseList(const Token& expected_begin,
+ const Token& expected_end);
+ scoped_ptr<ParseNode> ParseParenExpression();
+ scoped_ptr<UnaryOpNode> ParseUnaryOp();
+
+ bool IsToken(Token::Type type, char* str) const;
+
+ // Gets an error corresponding to the last token. When we hit an EOF
+ // usually we've already gone beyond the end (or maybe there are no tokens)
+ // so there is some tricky logic to report this.
+ Err MakeEOFError(const std::string& message,
+ const std::string& help = std::string()) const;
+
+ const Token& cur_token() const { return tokens_[cur_]; }
+
+ bool done() const { return at_end() || has_error(); }
+ bool at_end() const { return cur_ >= tokens_.size(); }
+ bool has_error() const { return err_->has_error(); }
+
+ const Token& next_token() const { return tokens_[cur_ + 1]; }
+ bool has_next_token() const { return cur_ + 1 < tokens_.size(); }
+
+ const std::vector<Token>& tokens_;
+
+ Err* err_;
+
+ // Current index into the tokens.
+ size_t cur_;
+
+ FRIEND_TEST_ALL_PREFIXES(Parser, BinaryOp);
+ FRIEND_TEST_ALL_PREFIXES(Parser, Block);
+ FRIEND_TEST_ALL_PREFIXES(Parser, Condition);
+ FRIEND_TEST_ALL_PREFIXES(Parser, Expression);
+ FRIEND_TEST_ALL_PREFIXES(Parser, FunctionCall);
+ FRIEND_TEST_ALL_PREFIXES(Parser, List);
+ FRIEND_TEST_ALL_PREFIXES(Parser, ParenExpression);
+ FRIEND_TEST_ALL_PREFIXES(Parser, UnaryOp);
+
+ DISALLOW_COPY_AND_ASSIGN(Parser);
+};
+
+#endif // TOOLS_GN_PARSER_H_
diff --git a/tools/gn/parser_unittest.cc b/tools/gn/parser_unittest.cc
new file mode 100644
index 0000000..3fd8ebe
--- /dev/null
+++ b/tools/gn/parser_unittest.cc
@@ -0,0 +1,329 @@
+// 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 <iostream>
+#include <sstream>
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "tools/gn/input_file.h"
+#include "tools/gn/parser.h"
+#include "tools/gn/tokenizer.h"
+
+namespace {
+
+bool GetTokens(const InputFile* input, std::vector<Token>* result) {
+ result->clear();
+ Err err;
+ *result = Tokenizer::Tokenize(input, &err);
+ return !err.has_error();
+}
+
+bool IsIdentifierEqual(const ParseNode* node, const char* val) {
+ if (!node)
+ return false;
+ const IdentifierNode* ident = node->AsIdentifier();
+ if (!ident)
+ return false;
+ return ident->value().value() == val;
+}
+
+bool IsLiteralEqual(const ParseNode* node, const char* val) {
+ if (!node)
+ return false;
+ const LiteralNode* lit = node->AsLiteral();
+ if (!lit)
+ return false;
+ return lit->value().value() == val;
+}
+
+// Returns true if the given node as a simple assignment to a given value.
+bool IsAssignment(const ParseNode* node, const char* ident, const char* value) {
+ if (!node)
+ return false;
+ const BinaryOpNode* binary = node->AsBinaryOp();
+ if (!binary)
+ return false;
+ return binary->op().IsOperatorEqualTo("=") &&
+ IsIdentifierEqual(binary->left(), ident) &&
+ IsLiteralEqual(binary->right(), value);
+}
+
+// Returns true if the given node is a block with one assignment statement.
+bool IsBlockWithAssignment(const ParseNode* node,
+ const char* ident, const char* value) {
+ if (!node)
+ return false;
+ const BlockNode* block = node->AsBlock();
+ if (!block)
+ return false;
+ if (block->statements().size() != 1)
+ return false;
+ return IsAssignment(block->statements()[0], ident, value);
+}
+
+void DoParserPrintTest(const char* input, const char* expected) {
+ std::vector<Token> tokens;
+ InputFile input_file(SourceFile("/test"));
+ input_file.SetContents(input);
+ ASSERT_TRUE(GetTokens(&input_file, &tokens));
+
+ Err err;
+ scoped_ptr<ParseNode> result = Parser::Parse(tokens, &err);
+ ASSERT_TRUE(result);
+
+ std::ostringstream collector;
+ result->Print(collector, 0);
+
+ EXPECT_EQ(expected, collector.str());
+}
+
+// Expects the tokenizer or parser to identify an error at the given line and
+// character.
+void DoParserErrorTest(const char* input, int err_line, int err_char) {
+ InputFile input_file(SourceFile("/test"));
+ input_file.SetContents(input);
+
+ Err err;
+ std::vector<Token> tokens = Tokenizer::Tokenize(&input_file, &err);
+ if (!err.has_error()) {
+ scoped_ptr<ParseNode> result = Parser::Parse(tokens, &err);
+ ASSERT_FALSE(result);
+ ASSERT_TRUE(err.has_error());
+ }
+
+ EXPECT_EQ(err_line, err.location().line_number());
+ EXPECT_EQ(err_char, err.location().char_offset());
+}
+
+} // namespace
+
+TEST(Parser, BinaryOp) {
+ std::vector<Token> tokens;
+
+ // Simple set expression.
+ InputFile expr_input(SourceFile("/test"));
+ expr_input.SetContents("a=2");
+ ASSERT_TRUE(GetTokens(&expr_input, &tokens));
+ Err err;
+ Parser set(tokens, &err);
+ scoped_ptr<ParseNode> expr = set.ParseExpression();
+ ASSERT_TRUE(expr);
+
+ const BinaryOpNode* binary_op = expr->AsBinaryOp();
+ ASSERT_TRUE(binary_op);
+
+ EXPECT_TRUE(binary_op->left()->AsIdentifier());
+
+ EXPECT_TRUE(binary_op->op().type() == Token::OPERATOR);
+ EXPECT_TRUE(binary_op->op().value() == "=");
+
+ EXPECT_TRUE(binary_op->right()->AsLiteral());
+}
+
+TEST(Parser, Condition) {
+ std::vector<Token> tokens;
+
+ InputFile cond_input(SourceFile("/test"));
+ cond_input.SetContents("if(1) { a = 2 }");
+ ASSERT_TRUE(GetTokens(&cond_input, &tokens));
+ Err err;
+ Parser simple_if(tokens, &err);
+ scoped_ptr<ConditionNode> cond = simple_if.ParseCondition();
+ ASSERT_TRUE(cond);
+
+ EXPECT_TRUE(IsLiteralEqual(cond->condition(), "1"));
+ EXPECT_FALSE(cond->if_false()); // No else block.
+ EXPECT_TRUE(IsBlockWithAssignment(cond->if_true(), "a", "2"));
+
+ // Now try a complicated if/else if/else one.
+ InputFile complex_if_input(SourceFile("/test"));
+ complex_if_input.SetContents(
+ "if(1) { a = 2 } else if (0) { a = 3 } else { a = 4 }");
+ ASSERT_TRUE(GetTokens(&complex_if_input, &tokens));
+ Parser complex_if(tokens, &err);
+ cond = complex_if.ParseCondition();
+ ASSERT_TRUE(cond);
+
+ EXPECT_TRUE(IsLiteralEqual(cond->condition(), "1"));
+ EXPECT_TRUE(IsBlockWithAssignment(cond->if_true(), "a", "2"));
+
+ ASSERT_TRUE(cond->if_false());
+ const ConditionNode* nested_cond = cond->if_false()->AsConditionNode();
+ ASSERT_TRUE(nested_cond);
+ EXPECT_TRUE(IsLiteralEqual(nested_cond->condition(), "0"));
+ EXPECT_TRUE(IsBlockWithAssignment(nested_cond->if_true(), "a", "3"));
+ EXPECT_TRUE(IsBlockWithAssignment(nested_cond->if_false(), "a", "4"));
+}
+
+TEST(Parser, FunctionCall) {
+ const char* input = "foo(a, 1, 2,) bar()";
+ const char* expected =
+ "BLOCK\n"
+ " FUNCTION(foo)\n"
+ " LIST\n"
+ " IDENTIFIER(a)\n"
+ " LITERAL(1)\n"
+ " LITERAL(2)\n"
+ " FUNCTION(bar)\n"
+ " LIST\n";
+ DoParserPrintTest(input, expected);
+}
+
+TEST(Parser, ParenExpression) {
+ const char* input = "(foo(1)) + (a + b)";
+ const char* expected =
+ "BLOCK\n"
+ " BINARY(+)\n"
+ " FUNCTION(foo)\n"
+ " LIST\n"
+ " LITERAL(1)\n"
+ " BINARY(+)\n"
+ " IDENTIFIER(a)\n"
+ " IDENTIFIER(b)\n";
+ DoParserPrintTest(input, expected);
+ DoParserErrorTest("(a +", 1, 4);
+}
+
+TEST(Parser, UnaryOp) {
+ std::vector<Token> tokens;
+
+ InputFile ident_input(SourceFile("/test"));
+ ident_input.SetContents("!foo");
+ ASSERT_TRUE(GetTokens(&ident_input, &tokens));
+ Err err;
+ Parser ident(tokens, &err);
+ scoped_ptr<UnaryOpNode> op = ident.ParseUnaryOp();
+
+ ASSERT_TRUE(op);
+ EXPECT_TRUE(op->op().type() == Token::OPERATOR);
+ EXPECT_TRUE(op->op().value() == "!");
+}
+
+TEST(Parser, CompleteFunction) {
+ const char* input =
+ "cc_test(\"foo\") {\n"
+ " sources = [\n"
+ " \"foo.cc\",\n"
+ " \"foo.h\"\n"
+ " ]\n"
+ " dependencies = [\n"
+ " \"base\"\n"
+ " ]\n"
+ "}\n";
+ const char* expected =
+ "BLOCK\n"
+ " FUNCTION(cc_test)\n"
+ " LIST\n"
+ " LITERAL(\"foo\")\n"
+ " BLOCK\n"
+ " BINARY(=)\n"
+ " IDENTIFIER(sources)\n"
+ " LIST\n"
+ " LITERAL(\"foo.cc\")\n"
+ " LITERAL(\"foo.h\")\n"
+ " BINARY(=)\n"
+ " IDENTIFIER(dependencies)\n"
+ " LIST\n"
+ " LITERAL(\"base\")\n";
+ DoParserPrintTest(input, expected);
+}
+
+TEST(Parser, FunctionWithConditional) {
+ const char* input =
+ "cc_test(\"foo\") {\n"
+ " sources = [\"foo.cc\"]\n"
+ " if (OS == \"mac\") {\n"
+ " sources += \"bar.cc\"\n"
+ " } else if (OS == \"win\") {\n"
+ " sources -= [\"asd.cc\", \"foo.cc\"]\n"
+ " } else {\n"
+ " dependencies += [\"bar.cc\"]\n"
+ " }\n"
+ "}\n";
+ const char* expected =
+ "BLOCK\n"
+ " FUNCTION(cc_test)\n"
+ " LIST\n"
+ " LITERAL(\"foo\")\n"
+ " BLOCK\n"
+ " BINARY(=)\n"
+ " IDENTIFIER(sources)\n"
+ " LIST\n"
+ " LITERAL(\"foo.cc\")\n"
+ " CONDITION\n"
+ " BINARY(==)\n"
+ " IDENTIFIER(OS)\n"
+ " LITERAL(\"mac\")\n"
+ " BLOCK\n"
+ " BINARY(+=)\n"
+ " IDENTIFIER(sources)\n"
+ " LITERAL(\"bar.cc\")\n"
+ " CONDITION\n"
+ " BINARY(==)\n"
+ " IDENTIFIER(OS)\n"
+ " LITERAL(\"win\")\n"
+ " BLOCK\n"
+ " BINARY(-=)\n"
+ " IDENTIFIER(sources)\n"
+ " LIST\n"
+ " LITERAL(\"asd.cc\")\n"
+ " LITERAL(\"foo.cc\")\n"
+ " BLOCK\n"
+ " BINARY(+=)\n"
+ " IDENTIFIER(dependencies)\n"
+ " LIST\n"
+ " LITERAL(\"bar.cc\")\n";
+ DoParserPrintTest(input, expected);
+}
+
+TEST(Parser, NestedBlocks) {
+ const char* input = "{cc_test(\"foo\") {{foo=1}{}}}";
+ const char* expected =
+ "BLOCK\n"
+ " BLOCK\n"
+ " FUNCTION(cc_test)\n"
+ " LIST\n"
+ " LITERAL(\"foo\")\n"
+ " BLOCK\n"
+ " BLOCK\n"
+ " BINARY(=)\n"
+ " IDENTIFIER(foo)\n"
+ " LITERAL(1)\n"
+ " BLOCK\n";
+ DoParserPrintTest(input, expected);
+}
+
+TEST(Parser, List) {
+ const char* input = "[] a = [1,asd,] b = [1, 2+3 - foo]";
+ const char* expected =
+ "BLOCK\n"
+ " LIST\n"
+ " BINARY(=)\n"
+ " IDENTIFIER(a)\n"
+ " LIST\n"
+ " LITERAL(1)\n"
+ " IDENTIFIER(asd)\n"
+ " BINARY(=)\n"
+ " IDENTIFIER(b)\n"
+ " LIST\n"
+ " LITERAL(1)\n"
+ " BINARY(+)\n"
+ " LITERAL(2)\n"
+ " BINARY(-)\n"
+ " LITERAL(3)\n"
+ " IDENTIFIER(foo)\n";
+ DoParserPrintTest(input, expected);
+
+ DoParserErrorTest("[a, 2+,]", 1, 7);
+ DoParserErrorTest("[,]", 1, 2);
+ DoParserErrorTest("[a,,]", 1, 4);
+}
+
+TEST(Parser, UnterminatedBlock) {
+ DoParserErrorTest("hello {", 1, 7);
+}
+
+TEST(Parser, BadlyTerminatedNumber) {
+ DoParserErrorTest("1234z", 1, 5);
+}
diff --git a/tools/gn/path_output.cc b/tools/gn/path_output.cc
new file mode 100644
index 0000000..f67b3d4
--- /dev/null
+++ b/tools/gn/path_output.cc
@@ -0,0 +1,116 @@
+// 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/path_output.h"
+
+#include "build/build_config.h"
+#include "tools/gn/filesystem_utils.h"
+#include "tools/gn/output_file.h"
+#include "tools/gn/string_utils.h"
+
+PathOutput::PathOutput(const SourceDir& current_dir,
+ EscapingMode escaping,
+ bool convert_slashes)
+ : current_dir_(current_dir) {
+ inverse_current_dir_ = InvertDir(current_dir_);
+
+ options_.mode = escaping;
+ options_.convert_slashes = convert_slashes;
+ options_.inhibit_quoting = false;
+
+ if (convert_slashes)
+ ConvertPathToSystem(&inverse_current_dir_);
+}
+
+PathOutput::~PathOutput() {
+}
+
+void PathOutput::WriteFile(std::ostream& out, const SourceFile& file) const {
+ WritePathStr(out, file.value());
+}
+
+void PathOutput::WriteDir(std::ostream& out,
+ const SourceDir& dir,
+ DirSlashEnding slash_ending) const {
+ if (dir.value() == "/") {
+ // Writing system root is always a slash (this will normally only come up
+ // on Posix systems).
+ out << "/";
+ } else if (dir.value() == "//") {
+ // Writing out the source root.
+ if (slash_ending == DIR_NO_LAST_SLASH) {
+ // The inverse_current_dir_ will contain a [back]slash at the end, so we
+ // can't just write it out.
+ if (inverse_current_dir_.empty()) {
+ out << ".";
+ } else {
+ out.write(inverse_current_dir_.c_str(),
+ inverse_current_dir_.size() - 1);
+ }
+ } else {
+ if (inverse_current_dir_.empty())
+ out << "./";
+ else
+ out << inverse_current_dir_;
+ }
+ } else if (slash_ending == DIR_INCLUDE_LAST_SLASH) {
+ WritePathStr(out, dir.value());
+ } else {
+ // DIR_NO_LAST_SLASH mode, just trim the last char.
+ WritePathStr(out, base::StringPiece(dir.value().data(),
+ dir.value().size() - 1));
+ }
+}
+
+void PathOutput::WriteFile(std::ostream& out, const OutputFile& file) const {
+ // Here we assume that the path is already preprocessed.
+ EscapeStringToStream(out, file.value(), options_);
+}
+
+void PathOutput::WriteSourceRelativeString(
+ std::ostream& out,
+ const base::StringPiece& str) const {
+ // Input begins with two slashes, is relative to source root. Strip off
+ // the two slashes when cat-ing it.
+ if (options_.mode == ESCAPE_SHELL) {
+ // Shell escaping needs an intermediate string since it may end up
+ // quoting the whole thing. On Windows, the slashes may already be
+ // converted to backslashes in inverse_current_dir_, but we assume that on
+ // Windows the escaper won't try to then escape the preconverted
+ // backslashes and will just pass them, so this is fine.
+ std::string intermediate;
+ intermediate.reserve(inverse_current_dir_.size() + str.size());
+ intermediate.assign(inverse_current_dir_.c_str(),
+ inverse_current_dir_.size());
+ intermediate.append(str.data(), str.size());
+
+ EscapeStringToStream(out,
+ base::StringPiece(intermediate.c_str(), intermediate.size()),
+ options_);
+ } else {
+ // Ninja (and none) escaping can avoid the intermediate string and
+ // reprocessing of the inverse_current_dir_.
+ out << inverse_current_dir_;
+ EscapeStringToStream(out, str, options_);
+ }
+}
+
+void PathOutput::WritePathStr(std::ostream& out,
+ const base::StringPiece& str) const {
+ DCHECK(str.size() > 0 && str[0] == '/');
+
+ if (str.size() >= 2 && str[1] == '/') {
+ WriteSourceRelativeString(out, str.substr(2));
+ } else {
+ // Input begins with one slash, don't write the current directory since
+ // it's system-absolute.
+#if defined(OS_WIN)
+ // On Windows, trim the leading slash, since the input for absolute
+ // paths will look like "/C:/foo/bar.txt".
+ EscapeStringToStream(out, str.substr(1), options_);
+#else
+ EscapeStringToStream(out, str, options_);
+#endif
+ }
+}
diff --git a/tools/gn/path_output.h b/tools/gn/path_output.h
new file mode 100644
index 0000000..00bdbee
--- /dev/null
+++ b/tools/gn/path_output.h
@@ -0,0 +1,80 @@
+// 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_PATH_OUTPUT_H_
+#define TOOLS_GN_PATH_OUTPUT_H_
+
+#include <iosfwd>
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/strings/string_piece.h"
+#include "tools/gn/escape.h"
+#include "tools/gn/source_dir.h"
+
+class OutputFile;
+class SourceFile;
+
+// Writes file names to streams assuming a certain input directory and
+// escaping rules. This gives us a central place for managing this state.
+class PathOutput {
+ public:
+ // Controls whether writing directory names include the trailing slash.
+ // Often we don't want the trailing slash when writing out to a command line,
+ // especially on Windows where it's a backslash and might be interpreted as
+ // escaping the thing following it.
+ enum DirSlashEnding {
+ DIR_INCLUDE_LAST_SLASH,
+ DIR_NO_LAST_SLASH,
+ };
+
+ PathOutput(const SourceDir& current_dir,
+ EscapingMode escaping,
+ bool convert_slashes);
+ ~PathOutput();
+
+ // Read-only since inverse_current_dir_ is computed depending on this.
+ EscapingMode escaping_mode() const { return options_.mode; }
+
+ // When true, converts slashes to the system-type path separators (on
+ // Windows, this is a backslash, this is a NOP otherwise).
+ //
+ // Read-only since inverse_current_dir_ is computed depending on this.
+ bool convert_slashes_to_system() const { return options_.convert_slashes; }
+
+ // When the output escaping is ESCAPE_SHELL, the escaper will normally put
+ // quotes around suspect things. If this value is set to true, we'll disable
+ // the quoting feature. This means that in ESCAPE_SHELL mode, strings with
+ // spaces in them qon't be quoted. This mode is for when quoting is done at
+ // some higher-level. Defaults to false.
+ bool inhibit_quoting() const { return options_.inhibit_quoting; }
+ void set_inhibit_quoting(bool iq) { options_.inhibit_quoting = iq; }
+
+ void WriteFile(std::ostream& out, const SourceFile& file) const;
+ void WriteFile(std::ostream& out, const OutputFile& file) const;
+ void WriteDir(std::ostream& out,
+ const SourceDir& dir,
+ DirSlashEnding slash_ending) const;
+
+ // Backend for WriteFile and WriteDir. This appends the given file or
+ // directory string to the file.
+ void WritePathStr(std::ostream& out, const base::StringPiece& str) const;
+
+ private:
+ // Takes the given string and writes it out, appending to the inverse
+ // current dir. This assumes leading slashes have been trimmed.
+ void WriteSourceRelativeString(std::ostream& out,
+ const base::StringPiece& str) const;
+
+ SourceDir current_dir_;
+
+ // Uses system slashes if convert_slashes_to_system_.
+ std::string inverse_current_dir_;
+
+ // Since the inverse_current_dir_ depends on some of these, we don't expose
+ // this directly to modification.
+ EscapeOptions options_;
+};
+
+#endif // TOOLS_GN_PATH_OUTPUT_H_
diff --git a/tools/gn/path_output_unittest.cc b/tools/gn/path_output_unittest.cc
new file mode 100644
index 0000000..5133b79
--- /dev/null
+++ b/tools/gn/path_output_unittest.cc
@@ -0,0 +1,193 @@
+// 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 <sstream>
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "tools/gn/path_output.h"
+#include "tools/gn/source_dir.h"
+#include "tools/gn/source_file.h"
+
+TEST(PathOutput, Basic) {
+ SourceDir build_dir("//out/Debug/");
+ PathOutput writer(build_dir, ESCAPE_NONE, false);
+ {
+ // Normal source-root path.
+ std::ostringstream out;
+ writer.WriteFile(out, SourceFile("//foo/bar.cc"));
+ EXPECT_EQ("../../foo/bar.cc", out.str());
+ }
+ {
+ // File in the root dir.
+ std::ostringstream out;
+ writer.WriteFile(out, SourceFile("//foo.cc"));
+ EXPECT_EQ("../../foo.cc", out.str());
+ }
+#if defined(OS_WIN)
+ {
+ // System-absolute path.
+ std::ostringstream out;
+ writer.WriteFile(out, SourceFile("/C:/foo/bar.cc"));
+ EXPECT_EQ("C:/foo/bar.cc", out.str());
+ }
+#else
+ {
+ // System-absolute path.
+ std::ostringstream out;
+ writer.WriteFile(out, SourceFile("/foo/bar.cc"));
+ EXPECT_EQ("/foo/bar.cc", out.str());
+ }
+#endif
+}
+
+// Same as basic but the output dir is the root.
+TEST(PathOutput, BasicInRoot) {
+ SourceDir build_dir("//");
+ PathOutput writer(build_dir, ESCAPE_NONE, false);
+ {
+ // Normal source-root path.
+ std::ostringstream out;
+ writer.WriteFile(out, SourceFile("//foo/bar.cc"));
+ EXPECT_EQ("foo/bar.cc", out.str());
+ }
+ {
+ // File in the root dir.
+ std::ostringstream out;
+ writer.WriteFile(out, SourceFile("//foo.cc"));
+ EXPECT_EQ("foo.cc", out.str());
+ }
+}
+
+TEST(PathOutput, NinjaEscaping) {
+ SourceDir build_dir("//out/Debug/");
+ PathOutput writer(build_dir, ESCAPE_NINJA, false);
+ {
+ // Spaces and $ in filenames.
+ std::ostringstream out;
+ writer.WriteFile(out, SourceFile("//foo/foo bar$.cc"));
+ EXPECT_EQ("../../foo/foo$ bar$$.cc", out.str());
+ }
+ {
+ // Not other weird stuff
+ std::ostringstream out;
+ writer.WriteFile(out, SourceFile("//foo/\"foo\\bar\".cc"));
+ EXPECT_EQ("../../foo/\"foo\\bar\".cc", out.str());
+ }
+}
+
+TEST(PathOutput, ShellEscaping) {
+ SourceDir build_dir("//out/Debug/");
+ PathOutput writer(build_dir, ESCAPE_SHELL, false);
+ {
+ // Spaces in filenames should get quoted.
+ std::ostringstream out;
+ writer.WriteFile(out, SourceFile("//foo/foo bar.cc"));
+ EXPECT_EQ("\"../../foo/foo bar.cc\"", out.str());
+ }
+ {
+ // Quotes should get blackslash-escaped.
+ std::ostringstream out;
+ writer.WriteFile(out, SourceFile("//foo/\"foobar\".cc"));
+ EXPECT_EQ("../../foo/\\\"foobar\\\".cc", out.str());
+ }
+ {
+ // Backslashes should get escaped on non-Windows and preserved on Windows.
+ std::ostringstream out;
+ writer.WriteFile(out, SourceFile("//foo\\bar.cc"));
+#if defined(OS_WIN)
+ EXPECT_EQ("../../foo\\bar.cc", out.str());
+#else
+ EXPECT_EQ("../../foo\\\\bar.cc", out.str());
+#endif
+ }
+}
+
+TEST(PathOutput, SlashConversion) {
+ SourceDir build_dir("//out/Debug/");
+ PathOutput writer(build_dir, ESCAPE_NINJA, true);
+ {
+ std::ostringstream out;
+ writer.WriteFile(out, SourceFile("//foo/bar.cc"));
+#if defined(OS_WIN)
+ EXPECT_EQ("..\\..\\foo\\bar.cc", out.str());
+#else
+ EXPECT_EQ("../../foo/bar.cc", out.str());
+#endif
+ }
+}
+
+TEST(PathOutput, InhibitQuoting) {
+ SourceDir build_dir("//out/Debug/");
+ PathOutput writer(build_dir, ESCAPE_SHELL, false);
+ writer.set_inhibit_quoting(true);
+ {
+ // We should get unescaped spaces in the output with no quotes.
+ std::ostringstream out;
+ writer.WriteFile(out, SourceFile("//foo/foo bar.cc"));
+ EXPECT_EQ("../../foo/foo bar.cc", out.str());
+ }
+}
+
+TEST(PathOutput, WriteDir) {
+ {
+ SourceDir build_dir("//out/Debug/");
+ PathOutput writer(build_dir, ESCAPE_NINJA, false);
+ {
+ std::ostringstream out;
+ writer.WriteDir(out, SourceDir("//foo/bar/"),
+ PathOutput::DIR_INCLUDE_LAST_SLASH);
+ EXPECT_EQ("../../foo/bar/", out.str());
+ }
+ {
+ std::ostringstream out;
+ writer.WriteDir(out, SourceDir("//foo/bar/"),
+ PathOutput::DIR_NO_LAST_SLASH);
+ EXPECT_EQ("../../foo/bar", out.str());
+ }
+
+ // Output source root dir.
+ {
+ std::ostringstream out;
+ writer.WriteDir(out, SourceDir("//"),
+ PathOutput::DIR_INCLUDE_LAST_SLASH);
+ EXPECT_EQ("../../", out.str());
+ }
+ {
+ std::ostringstream out;
+ writer.WriteDir(out, SourceDir("//"),
+ PathOutput::DIR_NO_LAST_SLASH);
+ EXPECT_EQ("../..", out.str());
+ }
+
+ // Output system root dir.
+ {
+ std::ostringstream out;
+ writer.WriteDir(out, SourceDir("/"),
+ PathOutput::DIR_INCLUDE_LAST_SLASH);
+ EXPECT_EQ("/", out.str());
+ }
+ {
+ std::ostringstream out;
+ writer.WriteDir(out, SourceDir("/"),
+ PathOutput::DIR_NO_LAST_SLASH);
+ EXPECT_EQ("/", out.str());
+ }
+ }
+ {
+ // Empty build dir writer.
+ PathOutput root_writer(SourceDir("//"), ESCAPE_NINJA, false);
+ {
+ std::ostringstream out;
+ root_writer.WriteDir(out, SourceDir("//"),
+ PathOutput::DIR_INCLUDE_LAST_SLASH);
+ EXPECT_EQ("./", out.str());
+ }
+ {
+ std::ostringstream out;
+ root_writer.WriteDir(out, SourceDir("//"),
+ PathOutput::DIR_NO_LAST_SLASH);
+ EXPECT_EQ(".", out.str());
+ }
+ }
+}
diff --git a/tools/gn/pattern.cc b/tools/gn/pattern.cc
new file mode 100644
index 0000000..cc08b2c
--- /dev/null
+++ b/tools/gn/pattern.cc
@@ -0,0 +1,185 @@
+// 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/pattern.h"
+
+#include "tools/gn/value.h"
+
+namespace {
+
+void ParsePattern(const std::string& s, std::vector<Pattern::Subrange>* out) {
+ // Set when the last subrange is a literal so we can just append when we
+ // find another literal.
+ Pattern::Subrange* last_literal = NULL;
+
+ for (size_t i = 0; i < s.size(); i++) {
+ if (s[i] == '*') {
+ // Don't allow two **.
+ if (out->size() == 0 ||
+ (*out)[out->size() - 1].type != Pattern::Subrange::ANYTHING)
+ out->push_back(Pattern::Subrange(Pattern::Subrange::ANYTHING));
+ last_literal = NULL;
+ } else if (s[i] == '\\') {
+ if (i < s.size() - 1 && s[i + 1] == 'b') {
+ // "\b" means path boundary.
+ i++;
+ out->push_back(Pattern::Subrange(Pattern::Subrange::PATH_BOUNDARY));
+ last_literal = NULL;
+ } else {
+ // Backslash + anything else means that literal char.
+ if (!last_literal) {
+ out->push_back(Pattern::Subrange(Pattern::Subrange::LITERAL));
+ last_literal = &(*out)[out->size() - 1];
+ }
+ if (i < s.size() - 1) {
+ i++;
+ last_literal->literal.push_back(s[i]);
+ } else {
+ // Single backslash at end, use literal backslash.
+ last_literal->literal.push_back('\\');
+ }
+ }
+ } else {
+ if (!last_literal) {
+ out->push_back(Pattern::Subrange(Pattern::Subrange::LITERAL));
+ last_literal = &(*out)[out->size() - 1];
+ }
+ last_literal->literal.push_back(s[i]);
+ }
+ }
+}
+
+} // namespace
+
+Pattern::Pattern(const std::string& s) {
+ ParsePattern(s, &subranges_);
+ is_suffix_ =
+ (subranges_.size() == 2 &&
+ subranges_[0].type == Subrange::ANYTHING &&
+ subranges_[1].type == Subrange::LITERAL);
+}
+
+Pattern::~Pattern() {
+}
+
+bool Pattern::MatchesString(const std::string& s) const {
+ // Empty pattern matches only empty string.
+ if (subranges_.empty())
+ return s.empty();
+
+ if (is_suffix_) {
+ const std::string& suffix = subranges_[1].literal;
+ if (suffix.size() > s.size())
+ return false; // Too short.
+ return s.compare(s.size() - suffix.size(), suffix.size(), suffix) == 0;
+ }
+
+ return RecursiveMatch(s, 0, 0, true);
+}
+
+// We assume the number of ranges is small so recursive is always reasonable.
+// Could be optimized to only be recursive for *.
+bool Pattern::RecursiveMatch(const std::string& s,
+ size_t begin_char,
+ size_t subrange_index,
+ bool allow_implicit_path_boundary) const {
+ if (subrange_index >= subranges_.size()) {
+ // Hit the end of our subranges, the text should also be at the end for a
+ // match.
+ return begin_char == s.size();
+ }
+
+ const Subrange& sr = subranges_[subrange_index];
+ switch (sr.type) {
+ case Subrange::LITERAL: {
+ if (s.size() - begin_char < sr.literal.size())
+ return false; // Not enough room.
+ if (s.compare(begin_char, sr.literal.size(), sr.literal) != 0)
+ return false; // Literal doesn't match.
+
+ // Recursively check the next one.
+ return RecursiveMatch(s, begin_char + sr.literal.size(),
+ subrange_index + 1, true);
+ }
+
+ case Subrange::PATH_BOUNDARY: {
+ // When we can accept an implicit path boundary, we have to check both
+ // a match of the literal and the implicit one.
+ if (allow_implicit_path_boundary &&
+ (begin_char == 0 || begin_char == s.size())) {
+ // At implicit path boundary, see if the rest of the pattern matches.
+ if (RecursiveMatch(s, begin_char, subrange_index + 1, false))
+ return true;
+ }
+
+ // Check for a literal "/".
+ if (begin_char < s.size() && s[begin_char] == '/') {
+ // At explicit boundary, see if the rest of the pattern matches.
+ if (RecursiveMatch(s, begin_char + 1, subrange_index + 1, true))
+ return true;
+ }
+ return false;
+ }
+
+ case Subrange::ANYTHING: {
+ if (subrange_index == subranges_.size() - 1)
+ return true; // * at the end, consider it matching.
+
+ size_t min_next_size = sr.MinSize();
+
+ // We don't care about exactly what matched as long as there was a match,
+ // so we can do this front-to-back. If we needed the match, we would
+ // normally want "*" to be greedy so would work backwards.
+ for (size_t i = begin_char; i < s.size() - min_next_size; i++) {
+ // Note: this could probably be faster by detecting the type of the
+ // next match in advance and checking for a match in this loop rather
+ // than doing a full recursive call for each character.
+ if (RecursiveMatch(s, i, subrange_index + 1, true))
+ return true;
+ }
+ return false;
+ }
+
+ default:
+ NOTREACHED();
+ }
+
+ return false;
+}
+
+PatternList::PatternList() {
+}
+
+PatternList::~PatternList() {
+}
+
+void PatternList::SetFromValue(const Value& v, Err* err) {
+ patterns_.clear();
+
+ if (v.type() != Value::LIST) {
+ *err = Err(v.origin(), "This value must be a list.");
+ return;
+ }
+
+ const std::vector<Value>& list = v.list_value();
+ for (size_t i = 0; i < list.size(); i++) {
+ if (!list[i].VerifyTypeIs(Value::STRING, err))
+ return;
+ patterns_.push_back(Pattern(list[i].string_value()));
+ }
+}
+
+bool PatternList::MatchesString(const std::string& s) const {
+ for (size_t i = 0; i < patterns_.size(); i++) {
+ if (patterns_[i].MatchesString(s))
+ return true;
+ }
+ return false;
+}
+
+bool PatternList::MatchesValue(const Value& v) const {
+ if (v.type() == Value::STRING)
+ return MatchesString(v.string_value());
+ return false;
+}
diff --git a/tools/gn/pattern.h b/tools/gn/pattern.h
new file mode 100644
index 0000000..582cfea
--- /dev/null
+++ b/tools/gn/pattern.h
@@ -0,0 +1,86 @@
+// 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_PATTERN_H_
+#define TOOLS_GN_PATTERN_H_
+
+#include <string>
+#include <vector>
+
+#include "tools/gn/value.h"
+
+class Pattern {
+ public:
+ struct Subrange {
+ enum Type {
+ LITERAL, // Matches exactly the contents of the string.
+ ANYTHING, // * (zero or more chars).
+ PATH_BOUNDARY // '/' or beginning of string.
+ };
+
+ Subrange(Type t, const std::string& l = std::string())
+ : type(t),
+ literal(l) {
+ }
+
+ // Returns the minimum number of chars that this subrange requires.
+ size_t MinSize() const {
+ switch (type) {
+ case LITERAL:
+ return literal.size();
+ case ANYTHING:
+ return 0;
+ case PATH_BOUNDARY:
+ return 0; // Can match beginning or end of string, which is 0 len.
+ default:
+ return 0;
+ }
+ }
+
+ Type type;
+
+ // When type == LITERAL this is the text to match.
+ std::string literal;
+ };
+
+ Pattern(const std::string& s);
+ ~Pattern();
+
+ // Returns true if the current pattern matches the given string.
+ bool MatchesString(const std::string& s) const;
+
+ private:
+ // allow_implicit_path_boundary determines if a path boundary should accept
+ // matches at the beginning or end of the string.
+ bool RecursiveMatch(const std::string& s,
+ size_t begin_char,
+ size_t subrange_index,
+ bool allow_implicit_path_boundary) const;
+
+ std::vector<Subrange> subranges_;
+
+ // Set to true when the subranges are "*foo" ("ANYTHING" followed by a
+ // literal). This covers most patterns so we optimize for this.
+ bool is_suffix_;
+};
+
+class PatternList {
+ public:
+ PatternList();
+ ~PatternList();
+
+ bool is_empty() const { return patterns_.empty(); }
+
+ // Initializes the pattern list from a give list of pattern strings. Sets
+ // |*err| on failure.
+ void SetFromValue(const Value& v, Err* err);
+
+ bool MatchesString(const std::string& s) const;
+ bool MatchesValue(const Value& v) const;
+
+ private:
+ std::vector<Pattern> patterns_;
+};
+
+#endif // TOOLS_GN_PATTERN_H_
diff --git a/tools/gn/pattern_unittest.cc b/tools/gn/pattern_unittest.cc
new file mode 100644
index 0000000..e9ffea6
--- /dev/null
+++ b/tools/gn/pattern_unittest.cc
@@ -0,0 +1,61 @@
+// 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/pattern.h"
+
+namespace {
+
+struct Case {
+ const char* pattern;
+ const char* candidate;
+ bool expected_match;
+};
+
+} // namespace
+
+TEST(Pattern, Matches) {
+ Case pattern_cases[] = {
+ // Empty pattern matches only empty string.
+ { "", "", true },
+ { "", "foo", false },
+ // Exact matches.
+ { "foo", "foo", true },
+ { "foo", "bar", false },
+ // Path boundaries.
+ { "\\b", "", true },
+ { "\\b", "/", true },
+ { "\\b\\b", "/", true },
+ { "\\b\\b\\b", "", false },
+ { "\\b\\b\\b", "/", true },
+ { "\\b", "//", false },
+ { "\\bfoo\\b", "foo", true },
+ { "\\bfoo\\b", "/foo/", true },
+ { "\\b\\bfoo", "/foo", true },
+ // *
+ { "*", "", true },
+ { "*", "foo", true },
+ { "*foo", "foo", true },
+ { "*foo", "gagafoo", true },
+ { "*foo", "gagafoob", false },
+ { "foo*bar", "foobar", true },
+ { "foo*bar", "foo-bar", true },
+ { "foo*bar", "foolalalalabar", true },
+ { "foo*bar", "foolalalalabaz", false },
+ { "*a*b*c*d*", "abcd", true },
+ { "*a*b*c*d*", "1a2b3c4d5", true },
+ { "*a*b*c*d*", "1a2b3c45", false },
+ { "*\\bfoo\\b*", "foo", true },
+ { "*\\bfoo\\b*", "/foo/", true },
+ { "*\\bfoo\\b*", "foob", false },
+ { "*\\bfoo\\b*", "lala/foo/bar/baz", true },
+ };
+ for (size_t i = 0; i < arraysize(pattern_cases); i++) {
+ const Case& c = pattern_cases[i];
+ Pattern pattern(c.pattern);
+ bool result = pattern.MatchesString(c.candidate);
+ EXPECT_EQ(c.expected_match, result) << i << ": \"" << c.pattern
+ << "\", \"" << c.candidate << "\"";
+ }
+}
diff --git a/tools/gn/scheduler.cc b/tools/gn/scheduler.cc
new file mode 100644
index 0000000..33c8f1a
--- /dev/null
+++ b/tools/gn/scheduler.cc
@@ -0,0 +1,130 @@
+// 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/scheduler.h"
+
+#include "base/bind.h"
+#include "tools/gn/ninja_target_writer.h"
+#include "tools/gn/standard_out.h"
+
+Scheduler* g_scheduler = NULL;
+
+Scheduler::Scheduler()
+ : pool_(new base::SequencedWorkerPool(32, "worker_")),
+ input_file_manager_(new InputFileManager),
+ verbose_logging_(false),
+ work_count_(0),
+ is_failed_(false) {
+ g_scheduler = this;
+}
+
+Scheduler::~Scheduler() {
+ g_scheduler = NULL;
+}
+
+bool Scheduler::Run() {
+ runner_.Run();
+ pool_->Shutdown();
+ return !is_failed();
+}
+
+void Scheduler::Log(const std::string& verb, const std::string& msg) {
+ if (base::MessageLoop::current() == &main_loop_) {
+ LogOnMainThread(verb, msg);
+ } else {
+ // The run loop always joins on the sub threads, so the lifetime of this
+ // object outlives the invocations of this function, hence "unretained".
+ main_loop_.PostTask(FROM_HERE,
+ base::Bind(&Scheduler::LogOnMainThread,
+ base::Unretained(this), verb, msg));
+ }
+}
+
+void Scheduler::FailWithError(const Err& err) {
+ DCHECK(err.has_error());
+ {
+ base::AutoLock lock(lock_);
+
+ if (is_failed_)
+ return; // Ignore errors once we see one.
+ is_failed_ = true;
+ }
+
+ if (base::MessageLoop::current() == &main_loop_) {
+ FailWithErrorOnMainThread(err);
+ } else {
+ // The run loop always joins on the sub threads, so the lifetime of this
+ // object outlives the invocations of this function, hence "unretained".
+ main_loop_.PostTask(FROM_HERE,
+ base::Bind(&Scheduler::FailWithErrorOnMainThread,
+ base::Unretained(this), err));
+ }
+}
+
+void Scheduler::ScheduleWork(const base::Closure& work) {
+ IncrementWorkCount();
+ pool_->PostWorkerTaskWithShutdownBehavior(
+ FROM_HERE, base::Bind(&Scheduler::DoWork,
+ base::Unretained(this), work),
+ base::SequencedWorkerPool::BLOCK_SHUTDOWN);
+}
+
+void Scheduler::ScheduleTargetFileWrite(const Target* target) {
+ pool_->PostWorkerTaskWithShutdownBehavior(
+ FROM_HERE, base::Bind(&Scheduler::DoTargetFileWrite,
+ base::Unretained(this), target),
+ base::SequencedWorkerPool::BLOCK_SHUTDOWN);
+}
+
+void Scheduler::AddGenDependency(const SourceFile& source_file) {
+ base::AutoLock lock(lock_);
+ gen_dependencies_.push_back(source_file);
+}
+
+std::vector<SourceFile> Scheduler::GetGenDependencies() const {
+ base::AutoLock lock(lock_);
+ return gen_dependencies_;
+}
+
+void Scheduler::IncrementWorkCount() {
+ base::AtomicRefCountInc(&work_count_);
+}
+
+void Scheduler::DecrementWorkCount() {
+ if (!base::AtomicRefCountDec(&work_count_)) {
+ if (base::MessageLoop::current() == &main_loop_) {
+ OnComplete();
+ } else {
+ main_loop_.PostTask(FROM_HERE,
+ base::Bind(&Scheduler::OnComplete,
+ base::Unretained(this)));
+ }
+ }
+}
+
+void Scheduler::LogOnMainThread(const std::string& verb,
+ const std::string& msg) {
+ OutputString(verb, DECORATION_YELLOW);
+ OutputString(" " + msg + "\n");
+}
+
+void Scheduler::FailWithErrorOnMainThread(const Err& err) {
+ err.PrintToStdout();
+ runner_.Quit();
+}
+
+void Scheduler::DoTargetFileWrite(const Target* target) {
+ NinjaTargetWriter::RunAndWriteFile(target);
+}
+
+void Scheduler::DoWork(const base::Closure& closure) {
+ closure.Run();
+ DecrementWorkCount();
+}
+
+void Scheduler::OnComplete() {
+ // Should be called on the main thread.
+ DCHECK(base::MessageLoop::current() == main_loop());
+ runner_.Quit();
+}
diff --git a/tools/gn/scheduler.h b/tools/gn/scheduler.h
new file mode 100644
index 0000000..eab996d
--- /dev/null
+++ b/tools/gn/scheduler.h
@@ -0,0 +1,90 @@
+// 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_SCHEDULER_H_
+#define TOOLS_GN_SCHEDULER_H_
+
+#include "base/atomic_ref_count.h"
+#include "base/basictypes.h"
+#include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
+#include "base/synchronization/lock.h"
+#include "base/threading/sequenced_worker_pool.h"
+#include "tools/gn/input_file_manager.h"
+
+class Target;
+
+// Maintains the thread pool and error state.
+class Scheduler {
+ public:
+ Scheduler();
+ ~Scheduler();
+
+ bool Run();
+
+ base::MessageLoop* main_loop() { return &main_loop_; }
+ base::SequencedWorkerPool* pool() { return pool_; }
+
+ InputFileManager* input_file_manager() { return input_file_manager_; }
+
+ bool verbose_logging() const { return verbose_logging_; }
+ void set_verbose_logging(bool v) { verbose_logging_ = v; }
+
+ // TODO(brettw) data race on this access (benign?).
+ bool is_failed() const { return is_failed_; }
+
+ void Log(const std::string& verb, const std::string& msg);
+ void FailWithError(const Err& err);
+
+ void ScheduleWork(const base::Closure& work);
+
+ void ScheduleTargetFileWrite(const Target* target);
+
+ // Declares that the given file was read and affected the build output.
+ //
+ // TODO(brettw) this is global rather than per-BuildSettings. If we
+ // start using >1 build settings, then we probably want this to take a
+ // BuildSettings object so we know the depdency on a per-build basis.
+ void AddGenDependency(const SourceFile& source_file);
+ std::vector<SourceFile> GetGenDependencies() const;
+
+ // We maintain a count of the things we need to do that works like a
+ // refcount. When this reaches 0, the program exits.
+ void IncrementWorkCount();
+ void DecrementWorkCount();
+
+ private:
+ void LogOnMainThread(const std::string& verb, const std::string& msg);
+ void FailWithErrorOnMainThread(const Err& err);
+
+ void DoTargetFileWrite(const Target* target);
+
+ void DoWork(const base::Closure& closure);
+
+ void OnComplete();
+
+ base::MessageLoop main_loop_;
+ scoped_refptr<base::SequencedWorkerPool> pool_;
+
+ scoped_refptr<InputFileManager> input_file_manager_;
+
+ base::RunLoop runner_;
+
+ bool verbose_logging_;
+
+ base::AtomicRefCount work_count_;
+
+ mutable base::Lock lock_;
+ bool is_failed_;
+
+ // Additional input dependencies. Protected by the lock.
+ std::vector<SourceFile> gen_dependencies_;
+
+ DISALLOW_COPY_AND_ASSIGN(Scheduler);
+};
+
+extern Scheduler* g_scheduler;
+
+#endif // TOOLS_GN_SCHEDULER_H_
+
diff --git a/tools/gn/scope.cc b/tools/gn/scope.cc
new file mode 100644
index 0000000..72664d7
--- /dev/null
+++ b/tools/gn/scope.cc
@@ -0,0 +1,372 @@
+// 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/scope.h"
+
+#include "base/logging.h"
+#include "base/stl_util.h"
+#include "tools/gn/parse_tree.h"
+
+namespace {
+
+// FLags set in the mode_flags_ of a scope. If a bit is set, it applies
+// recursively to all dependent scopes.
+const unsigned kProcessingBuildConfigFlag = 1;
+const unsigned kProcessingDefaultBuildConfigFlag = 2;
+const unsigned kProcessingImportFlag = 4;
+
+} // namespace
+
+Scope::Scope(const Settings* settings)
+ : const_containing_(NULL),
+ mutable_containing_(NULL),
+ settings_(settings),
+ mode_flags_(0) {
+}
+
+Scope::Scope(Scope* parent)
+ : const_containing_(NULL),
+ mutable_containing_(parent),
+ settings_(parent->settings()),
+ mode_flags_(0) {
+}
+
+Scope::Scope(const Scope* parent)
+ : const_containing_(parent),
+ mutable_containing_(NULL),
+ settings_(parent->settings()),
+ mode_flags_(0) {
+}
+
+Scope::~Scope() {
+ STLDeleteContainerPairSecondPointers(target_defaults_.begin(),
+ target_defaults_.end());
+}
+
+const Value* Scope::GetValue(const base::StringPiece& ident,
+ bool counts_as_used) {
+ // First check for programatically-provided values.
+ for (ProviderSet::const_iterator i = programmatic_providers_.begin();
+ i != programmatic_providers_.end(); ++i) {
+ const Value* v = (*i)->GetProgrammaticValue(ident);
+ if (v)
+ return v;
+ }
+
+ RecordMap::iterator found = values_.find(ident);
+ if (found != values_.end()) {
+ if (counts_as_used)
+ found->second.used = true;
+ return &found->second.value;
+ }
+
+ // Search in the parent scope.
+ if (const_containing_)
+ return const_containing_->GetValue(ident);
+ if (mutable_containing_)
+ return mutable_containing_->GetValue(ident, counts_as_used);
+ return NULL;
+}
+
+Value* Scope::GetValueForcedToCurrentScope(const base::StringPiece& ident,
+ const ParseNode* set_node) {
+ RecordMap::iterator found = values_.find(ident);
+ if (found != values_.end())
+ return &found->second.value; // Already have in the current scope.
+
+ // Search in the parent scope.
+ if (containing()) {
+ const Value* in_containing = containing()->GetValue(ident);
+ if (in_containing) {
+ // Promote to current scope.
+ return SetValue(ident, *in_containing, set_node);
+ }
+ }
+ return NULL;
+}
+
+const Value* Scope::GetValue(const base::StringPiece& ident) const {
+ RecordMap::const_iterator found = values_.find(ident);
+ if (found != values_.end())
+ return &found->second.value;
+ if (containing())
+ return containing()->GetValue(ident);
+ return NULL;
+}
+
+Value* Scope::SetValue(const base::StringPiece& ident,
+ const Value& v,
+ const ParseNode* set_node) {
+ Record& r = values_[ident]; // Clears any existing value.
+ r.value = v;
+ r.value.set_origin(set_node);
+ return &r.value;
+}
+
+bool Scope::AddTemplate(const std::string& name, const FunctionCallNode* decl) {
+ if (GetTemplate(name))
+ return false;
+ templates_[name] = decl;
+ return true;
+}
+
+const FunctionCallNode* Scope::GetTemplate(const std::string& name) const {
+ TemplateMap::const_iterator found = templates_.find(name);
+ if (found != templates_.end())
+ return found->second;
+ if (containing())
+ return containing()->GetTemplate(name);
+ return NULL;
+}
+
+void Scope::MarkUsed(const base::StringPiece& ident) {
+ RecordMap::iterator found = values_.find(ident);
+ if (found == values_.end()) {
+ NOTREACHED();
+ return;
+ }
+ found->second.used = true;
+}
+
+void Scope::MarkUnused(const base::StringPiece& ident) {
+ RecordMap::iterator found = values_.find(ident);
+ if (found == values_.end()) {
+ NOTREACHED();
+ return;
+ }
+ found->second.used = false;
+}
+
+bool Scope::IsSetButUnused(const base::StringPiece& ident) const {
+ RecordMap::const_iterator found = values_.find(ident);
+ if (found != values_.end()) {
+ if (!found->second.used) {
+ return true;
+ }
+ }
+ return false;
+}
+
+bool Scope::CheckForUnusedVars(Err* err) const {
+ for (RecordMap::const_iterator i = values_.begin();
+ i != values_.end(); ++i) {
+ if (!i->second.used) {
+ std::string help = "You set the variable \"" + i->first.as_string() +
+ "\" here and it was unused before it went\nout of scope.";
+
+ const BinaryOpNode* binary = i->second.value.origin()->AsBinaryOp();
+ if (binary) {
+ // Make a nicer error message for normal var sets.
+ *err = Err(binary->left()->GetRange(), "Assignment had no effect.",
+ help);
+ } else {
+ // This will happen for internally-generated variables.
+ *err = Err(i->second.value.origin(), "Assignment had no effect.", help);
+ }
+ return false;
+ }
+ }
+ return true;
+}
+
+void Scope::GetCurrentScopeValues(KeyValueVector* output) const {
+ output->reserve(values_.size());
+ for (RecordMap::const_iterator i = values_.begin(); i != values_.end(); ++i) {
+ output->push_back(std::make_pair(i->first, i->second.value));
+ }
+}
+
+bool Scope::NonRecursiveMergeTo(Scope* dest,
+ const ParseNode* node_for_err,
+ const char* desc_for_err,
+ Err* err) const {
+ // Values.
+ for (RecordMap::const_iterator i = values_.begin(); i != values_.end(); ++i) {
+ const Value* existing_value = dest->GetValue(i->first);
+ if (existing_value) {
+ // Value present in both the source and the dest.
+ std::string desc_string(desc_for_err);
+ *err = Err(node_for_err, "Value collision.",
+ "This " + desc_string + " contains \"" + i->first.as_string() + "\"");
+ err->AppendSubErr(Err(i->second.value, "defined here.",
+ "Which would clobber the one in your current scope"));
+ err->AppendSubErr(Err(*existing_value, "defined here.",
+ "Executing " + desc_string + " should not conflict with anything "
+ "in the current\nscope."));
+ return false;
+ }
+ dest->values_[i->first] = i->second;
+ }
+
+ // Target defaults are owning pointers.
+ for (NamedScopeMap::const_iterator i = target_defaults_.begin();
+ i != target_defaults_.end(); ++i) {
+ if (dest->GetTargetDefaults(i->first)) {
+ // TODO(brettw) it would be nice to know the origin of a
+ // set_target_defaults so we can give locations for the colliding target
+ // defaults.
+ std::string desc_string(desc_for_err);
+ *err = Err(node_for_err, "Target defaults collision.",
+ "This " + desc_string + " contains target defaults for\n"
+ "\"" + i->first + "\" which would clobber one for the\n"
+ "same target type in your current scope. It's unfortunate that I'm "
+ "too stupid\nto tell you the location of where the target defaults "
+ "were set. Usually\nthis happens in the BUILDCONFIG.gn file.");
+ return false;
+ }
+
+ Scope* s = new Scope(settings_);
+ i->second->NonRecursiveMergeTo(s, node_for_err, "<SHOULDN'T HAPPEN>", err);
+ dest->target_defaults_[i->first] = s;
+ }
+
+ // Sources assignment filter.
+ if (sources_assignment_filter_) {
+ if (dest->GetSourcesAssignmentFilter()) {
+ // Sources assignment filter present in both the source and the dest.
+ std::string desc_string(desc_for_err);
+ *err = Err(node_for_err, "Assignment filter collision.",
+ "The " + desc_string + " contains a sources_assignment_filter which\n"
+ "would clobber the one in your current scope.");
+ return false;
+ }
+ dest->sources_assignment_filter_.reset(
+ new PatternList(*sources_assignment_filter_));
+ }
+
+ // Templates.
+ for (TemplateMap::const_iterator i = templates_.begin();
+ i != templates_.end(); ++i) {
+ const FunctionCallNode* existing_template = dest->GetTemplate(i->first);
+ if (existing_template) {
+ // Rule present in both the source and the dest.
+ std::string desc_string(desc_for_err);
+ *err = Err(node_for_err, "Template collision.",
+ "This " + desc_string + " contains a template \"" + i->first + "\"");
+ err->AppendSubErr(Err(i->second->function(), "defined here.",
+ "Which would clobber the one in your current scope"));
+ err->AppendSubErr(Err(existing_template->function(), "defined here.",
+ "Executing " + desc_string + " should not conflict with anything "
+ "in the current\nscope."));
+ return false;
+ }
+ dest->templates_.insert(*i);
+ }
+
+ return true;
+}
+
+Scope* Scope::MakeTargetDefaults(const std::string& target_type) {
+ if (GetTargetDefaults(target_type))
+ return NULL;
+
+ Scope** dest = &target_defaults_[target_type];
+ if (*dest) {
+ NOTREACHED(); // Already set.
+ return *dest;
+ }
+ *dest = new Scope(settings_);
+ return *dest;
+}
+
+const Scope* Scope::GetTargetDefaults(const std::string& target_type) const {
+ NamedScopeMap::const_iterator found = target_defaults_.find(target_type);
+ if (found != target_defaults_.end())
+ return found->second;
+ if (containing())
+ return containing()->GetTargetDefaults(target_type);
+ return NULL;
+}
+
+const PatternList* Scope::GetSourcesAssignmentFilter() const {
+ if (sources_assignment_filter_)
+ return sources_assignment_filter_.get();
+ if (containing())
+ return containing()->GetSourcesAssignmentFilter();
+ return NULL;
+}
+
+void Scope::SetProcessingBuildConfig() {
+ DCHECK((mode_flags_ & kProcessingBuildConfigFlag) == 0);
+ mode_flags_ |= kProcessingBuildConfigFlag;
+}
+
+void Scope::ClearProcessingBuildConfig() {
+ DCHECK(mode_flags_ & kProcessingBuildConfigFlag);
+ mode_flags_ &= ~(kProcessingBuildConfigFlag);
+}
+
+bool Scope::IsProcessingBuildConfig() const {
+ if (mode_flags_ & kProcessingBuildConfigFlag)
+ return true;
+ if (containing())
+ return containing()->IsProcessingBuildConfig();
+ return false;
+}
+
+void Scope::SetProcessingDefaultBuildConfig() {
+ DCHECK((mode_flags_ & kProcessingDefaultBuildConfigFlag) == 0);
+ mode_flags_ |= kProcessingDefaultBuildConfigFlag;
+}
+
+void Scope::ClearProcessingDefaultBuildConfig() {
+ DCHECK(mode_flags_ & kProcessingDefaultBuildConfigFlag);
+ mode_flags_ &= ~(kProcessingDefaultBuildConfigFlag);
+}
+
+bool Scope::IsProcessingDefaultBuildConfig() const {
+ if (mode_flags_ & kProcessingDefaultBuildConfigFlag)
+ return true;
+ if (containing())
+ return containing()->IsProcessingDefaultBuildConfig();
+ return false;
+}
+
+void Scope::SetProcessingImport() {
+ DCHECK((mode_flags_ & kProcessingImportFlag) == 0);
+ mode_flags_ |= kProcessingImportFlag;
+}
+
+void Scope::ClearProcessingImport() {
+ DCHECK(mode_flags_ & kProcessingImportFlag);
+ mode_flags_ &= ~(kProcessingImportFlag);
+}
+
+bool Scope::IsProcessingImport() const {
+ if (mode_flags_ & kProcessingImportFlag)
+ return true;
+ if (containing())
+ return containing()->IsProcessingImport();
+ return false;
+}
+
+void Scope::SetProperty(const void* key, void* value) {
+ if (!value) {
+ DCHECK(properties_.find(key) != properties_.end());
+ properties_.erase(key);
+ } else {
+ properties_[key] = value;
+ }
+}
+
+void* Scope::GetProperty(const void* key, const Scope** found_on_scope) const {
+ PropertyMap::const_iterator found = properties_.find(key);
+ if (found != properties_.end()) {
+ if (found_on_scope)
+ *found_on_scope = this;
+ return found->second;
+ }
+ if (containing())
+ return containing()->GetProperty(key, found_on_scope);
+ return NULL;
+}
+
+void Scope::AddProvider(ProgrammaticProvider* p) {
+ programmatic_providers_.insert(p);
+}
+
+void Scope::RemoveProvider(ProgrammaticProvider* p) {
+ DCHECK(programmatic_providers_.find(p) != programmatic_providers_.end());
+ programmatic_providers_.erase(p);
+}
diff --git a/tools/gn/scope.h b/tools/gn/scope.h
new file mode 100644
index 0000000..7d0547e
--- /dev/null
+++ b/tools/gn/scope.h
@@ -0,0 +1,260 @@
+// 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_SCOPE_H_
+#define TOOLS_GN_SCOPE_H_
+
+#include <map>
+#include <set>
+
+#include "base/basictypes.h"
+#include "base/containers/hash_tables.h"
+#include "base/memory/scoped_ptr.h"
+#include "tools/gn/err.h"
+#include "tools/gn/pattern.h"
+#include "tools/gn/value.h"
+
+class FunctionCallNode;
+class ImportManager;
+class ParseNode;
+class Settings;
+class TargetManager;
+
+// Scope for the script execution.
+//
+// Scopes are nested. Writing goes into the toplevel scope, reading checks
+// values resursively down the stack until a match is found or there are no
+// more containing scopes.
+//
+// A containing scope can be const or non-const. The const containing scope is
+// used primarily to refer to the master build config which is shared across
+// many invocations. A const containing scope, however, prevents us from
+// marking variables "used" which prevents us from issuing errors on unused
+// variables. So you should use a non-const containing scope whenever possible.
+class Scope {
+ public:
+ typedef std::vector<std::pair<base::StringPiece, Value> > KeyValueVector;
+
+ // Allows code to provide values for built-in variables. This class will
+ // automatically register itself on construction and deregister itself on
+ // destruction.
+ class ProgrammaticProvider {
+ public:
+ ProgrammaticProvider(Scope* scope) : scope_(scope) {
+ scope_->AddProvider(this);
+ }
+ ~ProgrammaticProvider() {
+ scope_->RemoveProvider(this);
+ }
+
+ // Returns a non-null value if the given value can be programmatically
+ // generated, or NULL if there is none.
+ virtual const Value* GetProgrammaticValue(
+ const base::StringPiece& ident) = 0;
+
+ protected:
+ Scope* scope_;
+ };
+
+ // Creates an empty toplevel scope.
+ Scope(const Settings* settings);
+
+ // Creates a dependent scope.
+ Scope(Scope* parent);
+ Scope(const Scope* parent);
+
+ ~Scope();
+
+ const Settings* settings() const { return settings_; }
+
+ // See the const_/mutable_containing_ var declaraions below. Yes, it's a
+ // bit weird that we can have a const pointer to the "mutable" one.
+ Scope* mutable_containing() { return mutable_containing_; }
+ const Scope* mutable_containing() const { return mutable_containing_; }
+ const Scope* const_containing() const { return const_containing_; }
+ const Scope* containing() const {
+ return mutable_containing_ ? mutable_containing_ : const_containing_;
+ }
+
+ // Returns NULL if there's no such value.
+ //
+ // counts_as_used should be set if the variable is being read in a way that
+ // should count for unused variable checking.
+ const Value* GetValue(const base::StringPiece& ident,
+ bool counts_as_used);
+ const Value* GetValue(const base::StringPiece& ident) const;
+
+ // Same as GetValue, but if the value exists in a parent scope, we'll copy
+ // it to the current scope. If the return value is non-null, the value is
+ // guaranteed to be set in the current scope. Generatlly this will be used
+ // if the calling code is planning on modifying the value in-place.
+ //
+ // Since this is used when doing read-modifies, we never count this access
+ // as reading the variable, since we assume it will be written to.
+ Value* GetValueForcedToCurrentScope(const base::StringPiece& ident,
+ const ParseNode* set_node);
+
+ // The set_node indicates the statement that caused the set, for displaying
+ // errors later. Returns a pointer to the value in the current scope (a copy
+ // is made for storage).
+ Value* SetValue(const base::StringPiece& ident,
+ const Value& v,
+ const ParseNode* set_node);
+
+ // Templates associated with this scope. A template can only be set once, so
+ // AddTemplate will fail and return NULL if a rule with that name already
+ // exists. GetTemplate returns NULL if the rule doesn't exist, and it will
+ // check all containing scoped rescursively.
+ bool AddTemplate(const std::string& name, const FunctionCallNode* decl);
+ const FunctionCallNode* GetTemplate(const std::string& name) const;
+
+ // Marks the given identifier as (un)used in the current scope.
+ void MarkUsed(const base::StringPiece& ident);
+ void MarkUnused(const base::StringPiece& ident);
+
+ // Checks to see if the scope has a var set that hasn't been used. This is
+ // called before replacing the var with a different one. It does not check
+ // containing scopes.
+ //
+ // If the identifier is present but hasnn't been used, return true.
+ bool IsSetButUnused(const base::StringPiece& ident) const;
+
+ // Checks the scope to see if any values were set but not used, and fills in
+ // the error and returns false if they were.
+ bool CheckForUnusedVars(Err* err) const;
+
+ // Returns all values set in the current scope, without going to the parent
+ // scopes.
+ void GetCurrentScopeValues(KeyValueVector* output) const;
+
+ // Copies this scope's values into the destination. Values from the
+ // containing scope(s) (normally shadowed into the current one) will not be
+ // copied, neither will the reference to the containing scope (this is why
+ // it's "non-recursive").
+ //
+ // It is an error to merge a variable into a scope that already has something
+ // with that name in scope (meaning in that scope or in any of its containing
+ // scopes). If this happens, the error will be set and the function will
+ // return false.
+ //
+ // This is used in different contexts. When generating the error, the given
+ // parse node will be blamed, and the given desc will be used to describe
+ // the operation that doesn't support doing this. For example, desc_for_err
+ // would be "import" when doing an import, and the error string would say
+ // something like "The import contains...".
+ bool NonRecursiveMergeTo(Scope* dest,
+ const ParseNode* node_for_err,
+ const char* desc_for_err,
+ Err* err) const;
+
+ // Makes an empty scope with the given name. Returns NULL if the name is
+ // already set.
+ Scope* MakeTargetDefaults(const std::string& target_type);
+
+ // Gets the scope associated with the given target name, or null if it hasn't
+ // been set.
+ const Scope* GetTargetDefaults(const std::string& target_type) const;
+
+ // Filter to apply when the sources variable is assigned. May return NULL.
+ const PatternList* GetSourcesAssignmentFilter() const;
+ void set_sources_assignment_filter(
+ scoped_ptr<PatternList> f) {
+ sources_assignment_filter_ = f.Pass();
+ }
+
+ // Indicates if we're currently processing the build configuration file.
+ // This is true when processing the config file for any toolchain. See also
+ // *ProcessingDefaultBuildConfig() below.
+ //
+ // To set or clear the flag, it must currently be in the opposite state in
+ // the current scope. Note that querying the state of the flag recursively
+ // checks all containing scopes until it reaches the top or finds the flag
+ // set.
+ void SetProcessingBuildConfig();
+ void ClearProcessingBuildConfig();
+ bool IsProcessingBuildConfig() const;
+
+ // Indicates we're currently processing the default toolchain's build
+ // configuration file.
+ void SetProcessingDefaultBuildConfig();
+ void ClearProcessingDefaultBuildConfig();
+ bool IsProcessingDefaultBuildConfig() const;
+
+ // Indicates if we're currently processing an import file.
+ //
+ // See SetProcessingBaseConfig for how flags work.
+ void SetProcessingImport();
+ void ClearProcessingImport();
+ bool IsProcessingImport() const;
+
+ // Properties are opaque pointers that code can use to set state on a Scope
+ // that it can retrieve later.
+ //
+ // The key should be a pointer to some use-case-specific object (to avoid
+ // collisions, otherwise it doesn't matter). Memory management is up to the
+ // setter. Setting the value to NULL will delete the property.
+ //
+ // Getting a property recursively searches all scopes, and the optional
+ // |found_on_scope| variable will be filled with the actual scope containing
+ // the key (if the pointer is non-NULL).
+ void SetProperty(const void* key, void* value);
+ void* GetProperty(const void* key, const Scope** found_on_scope) const;
+
+ private:
+ friend class ProgrammaticProvider;
+
+ struct Record {
+ Record() : used(false) {}
+ Record(const Value& v) : used(false), value(v) {}
+
+ bool used; // Set to true when the variable is used.
+ Value value;
+ };
+
+ void AddProvider(ProgrammaticProvider* p);
+ void RemoveProvider(ProgrammaticProvider* p);
+
+ // Scopes can have no containing scope (both null), a mutable containing
+ // scope, or a const containing scope. The reason is that when we're doing
+ // a new target, we want to refer to the base_config scope which will be read
+ // by multiple threads at the same time, so we REALLY want it to be const.
+ // When you jsut do a nested {}, however, we sometimes want to be able to
+ // change things (especially marking unused vars).
+ const Scope* const_containing_;
+ Scope* mutable_containing_;
+
+ const Settings* settings_;
+
+ // Bits set for different modes. See the flag definitions in the .cc file
+ // for more.
+ unsigned mode_flags_;
+
+ typedef base::hash_map<base::StringPiece, Record> RecordMap;
+ RecordMap values_;
+
+ // Owning pointers. Note that this can't use string pieces since the names
+ // are constructed from Values which might be deallocated before this goes
+ // out of scope.
+ typedef base::hash_map<std::string, Scope*> NamedScopeMap;
+ NamedScopeMap target_defaults_;
+
+ // Null indicates not set and that we should fallback to the containing
+ // scope's filter.
+ scoped_ptr<PatternList> sources_assignment_filter_;
+
+ // Non-owning pointers, the function calls are owned by the input file which
+ // should be kept around by the input file manager.
+ typedef std::map<std::string, const FunctionCallNode*> TemplateMap;
+ TemplateMap templates_;
+
+ typedef std::map<const void*, void*> PropertyMap;
+ PropertyMap properties_;
+
+ typedef std::set<ProgrammaticProvider*> ProviderSet;
+ ProviderSet programmatic_providers_;
+
+ DISALLOW_COPY_AND_ASSIGN(Scope);
+};
+
+#endif // TOOLS_GN_SCOPE_H_
diff --git a/tools/gn/scope_per_file_provider.cc b/tools/gn/scope_per_file_provider.cc
new file mode 100644
index 0000000..1799d9e
--- /dev/null
+++ b/tools/gn/scope_per_file_provider.cc
@@ -0,0 +1,186 @@
+// 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/scope_per_file_provider.h"
+
+#include "tools/gn/filesystem_utils.h"
+#include "tools/gn/settings.h"
+#include "tools/gn/source_file.h"
+#include "tools/gn/toolchain_manager.h"
+#include "tools/gn/value.h"
+
+const char* ScopePerFileProvider::kDefaultToolchain =
+ "default_toolchain";
+const char* ScopePerFileProvider::kPythonPath =
+ "python_path";
+const char* ScopePerFileProvider::kToolchain =
+ "toolchain";
+const char* ScopePerFileProvider::kRootOutputDirName =
+ "root_output_dir";
+const char* ScopePerFileProvider::kRootGenDirName =
+ "root_gen_dir";
+const char* ScopePerFileProvider::kTargetOutputDirName =
+ "target_output_dir";
+const char* ScopePerFileProvider::kTargetGenDirName =
+ "target_gen_dir";
+const char* ScopePerFileProvider::kRelativeRootOutputDirName =
+ "relative_root_output_dir";
+const char* ScopePerFileProvider::kRelativeRootGenDirName =
+ "relative_root_gen_dir";
+const char* ScopePerFileProvider::kRelativeTargetOutputDirName =
+ "relative_target_output_dir";
+const char* ScopePerFileProvider::kRelativeTargetGenDirName =
+ "relative_target_gen_dir";
+
+ScopePerFileProvider::ScopePerFileProvider(Scope* scope,
+ const SourceFile& source_file)
+ : ProgrammaticProvider(scope),
+ source_file_(source_file) {
+}
+
+ScopePerFileProvider::~ScopePerFileProvider() {
+}
+
+const Value* ScopePerFileProvider::GetProgrammaticValue(
+ const base::StringPiece& ident) {
+ if (ident == kDefaultToolchain)
+ return GetDefaultToolchain();
+ if (ident == kPythonPath)
+ return GetPythonPath();
+
+ if (ident == kTargetOutputDirName)
+ return GetTargetOutputDir();
+ if (ident == kTargetGenDirName)
+ return GetTargetGenDir();
+
+ if (ident == kRelativeRootOutputDirName)
+ return GetRelativeRootOutputDir();
+ if (ident == kRelativeRootGenDirName)
+ return GetRelativeRootGenDir();
+ if (ident == kRelativeTargetOutputDirName)
+ return GetRelativeTargetOutputDir();
+ if (ident == kRelativeTargetGenDirName)
+ return GetRelativeTargetGenDir();
+ return NULL;
+}
+
+// static
+Value ScopePerFileProvider::GetRootOutputDir(const Settings* settings) {
+ return Value(NULL, GetRootOutputDirWithNoLastSlash(settings));
+}
+
+// static
+Value ScopePerFileProvider::GetRootGenDir(const Settings* settings) {
+ return Value(NULL, GetRootGenDirWithNoLastSlash(settings));
+}
+
+const Value* ScopePerFileProvider::GetDefaultToolchain() {
+ if (!default_toolchain_) {
+ const ToolchainManager& toolchain_manager =
+ scope_->settings()->build_settings()->toolchain_manager();
+ default_toolchain_.reset(new Value(NULL,
+ toolchain_manager.GetDefaultToolchainUnlocked().GetUserVisibleName(
+ false)));
+ }
+ return default_toolchain_.get();
+}
+
+const Value* ScopePerFileProvider::GetPythonPath() {
+ if (!python_path_) {
+ python_path_.reset(new Value(NULL,
+ FilePathToUTF8(scope_->settings()->build_settings()->python_path())));
+ }
+ return python_path_.get();
+}
+
+const Value* ScopePerFileProvider::GetToolchain() {
+ if (!toolchain_) {
+ toolchain_.reset(new Value(NULL,
+ scope_->settings()->toolchain()->label().GetUserVisibleName(false)));
+ }
+ return toolchain_.get();
+}
+
+const Value* ScopePerFileProvider::GetTargetOutputDir() {
+ if (!target_output_dir_) {
+ target_output_dir_.reset(new Value(NULL,
+ GetRootOutputDirWithNoLastSlash(scope_->settings()) +
+ GetFileDirWithNoLastSlash()));
+ }
+ return target_output_dir_.get();
+}
+
+const Value* ScopePerFileProvider::GetTargetGenDir() {
+ if (!target_output_dir_) {
+ target_gen_dir_.reset(new Value(NULL,
+ GetRootGenDirWithNoLastSlash(scope_->settings()) +
+ GetFileDirWithNoLastSlash()));
+ }
+ return target_gen_dir_.get();
+}
+
+const Value* ScopePerFileProvider::GetRelativeRootOutputDir() {
+ if (!relative_root_output_dir_) {
+ relative_root_output_dir_.reset(new Value(NULL,
+ GetRelativeRootWithNoLastSlash() +
+ GetRootOutputDirWithNoLastSlash(scope_->settings())));
+ }
+ return relative_root_output_dir_.get();
+}
+
+const Value* ScopePerFileProvider::GetRelativeRootGenDir() {
+ if (!relative_root_gen_dir_) {
+ relative_root_gen_dir_.reset(new Value(NULL,
+ GetRelativeRootWithNoLastSlash() +
+ GetRootGenDirWithNoLastSlash(scope_->settings())));
+ }
+ return relative_root_gen_dir_.get();
+}
+
+const Value* ScopePerFileProvider::GetRelativeTargetOutputDir() {
+ if (!relative_target_output_dir_) {
+ relative_target_output_dir_.reset(new Value(NULL,
+ GetRelativeRootWithNoLastSlash() +
+ GetRootOutputDirWithNoLastSlash(scope_->settings()) + "obj/" +
+ GetFileDirWithNoLastSlash()));
+ }
+ return relative_target_output_dir_.get();
+}
+
+const Value* ScopePerFileProvider::GetRelativeTargetGenDir() {
+ if (!relative_target_gen_dir_) {
+ relative_target_gen_dir_.reset(new Value(NULL,
+ GetRelativeRootWithNoLastSlash() +
+ GetRootGenDirWithNoLastSlash(scope_->settings()) +
+ GetFileDirWithNoLastSlash()));
+ }
+ return relative_target_gen_dir_.get();
+}
+
+// static
+std::string ScopePerFileProvider::GetRootOutputDirWithNoLastSlash(
+ const Settings* settings) {
+ const std::string& output_dir =
+ settings->build_settings()->build_dir().value();
+ CHECK(!output_dir.empty());
+ return output_dir.substr(0, output_dir.size() - 1);
+}
+
+// static
+std::string ScopePerFileProvider::GetRootGenDirWithNoLastSlash(
+ const Settings* settings) {
+ return GetRootOutputDirWithNoLastSlash(settings) + "/gen";
+}
+
+std::string ScopePerFileProvider::GetFileDirWithNoLastSlash() const {
+ std::string dir_value = source_file_.GetDir().value();
+ return dir_value.substr(0, dir_value.size() - 1);
+}
+
+std::string ScopePerFileProvider::GetRelativeRootWithNoLastSlash() const {
+ std::string inverted = InvertDir(source_file_.GetDir());
+ if (inverted.empty())
+ return ".";
+ return inverted.substr(0, inverted.size() - 1);
+}
diff --git a/tools/gn/scope_per_file_provider.h b/tools/gn/scope_per_file_provider.h
new file mode 100644
index 0000000..1edb769
--- /dev/null
+++ b/tools/gn/scope_per_file_provider.h
@@ -0,0 +1,79 @@
+// 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_SCOPE_PER_FILE_PROVIDER_H_
+#define TOOLS_GN_SCOPE_PER_FILE_PROVIDER_H_
+
+#include "base/basictypes.h"
+#include "base/memory/scoped_ptr.h"
+#include "tools/gn/scope.h"
+#include "tools/gn/source_file.h"
+
+// ProgrammaticProvider for a scope to provide it with per-file built-in
+// variable support.
+class ScopePerFileProvider : public Scope::ProgrammaticProvider {
+ public:
+ ScopePerFileProvider(Scope* scope, const SourceFile& source_file);
+ virtual ~ScopePerFileProvider();
+
+ // ProgrammaticProvider implementation.
+ virtual const Value* GetProgrammaticValue(
+ const base::StringPiece& ident) OVERRIDE;
+
+ // Returns the value to expose to script for the given thing. These values
+ // are acually set globally, but are put here so we can keep all logic
+ // for converting paths to built-in values in this one file.
+ static Value GetRootOutputDir(const Settings* settings);
+ static Value GetRootGenDir(const Settings* settings);
+
+ // Variable names. These two should be set globally independent of the file
+ // being processed.
+ static const char* kRootOutputDirName;
+ static const char* kRootGenDirName;
+
+ // Variable names. These are provided by this class as needed.
+ static const char* kDefaultToolchain;
+ static const char* kPythonPath;
+ static const char* kToolchain;
+ static const char* kTargetOutputDirName;
+ static const char* kTargetGenDirName;
+ static const char* kRelativeRootOutputDirName;
+ static const char* kRelativeRootGenDirName;
+ static const char* kRelativeTargetOutputDirName;
+ static const char* kRelativeTargetGenDirName;
+
+ private:
+ const Value* GetDefaultToolchain();
+ const Value* GetPythonPath();
+ const Value* GetToolchain();
+ const Value* GetTargetOutputDir();
+ const Value* GetTargetGenDir();
+ const Value* GetRelativeRootOutputDir();
+ const Value* GetRelativeRootGenDir();
+ const Value* GetRelativeTargetOutputDir();
+ const Value* GetRelativeTargetGenDir();
+
+ static std::string GetRootOutputDirWithNoLastSlash(const Settings* settings);
+ static std::string GetRootGenDirWithNoLastSlash(const Settings* settings);
+
+ std::string GetFileDirWithNoLastSlash() const;
+ std::string GetRelativeRootWithNoLastSlash() const;
+
+ SourceFile source_file_;
+
+ // All values are lazily created.
+ scoped_ptr<Value> default_toolchain_;
+ scoped_ptr<Value> python_path_;
+ scoped_ptr<Value> toolchain_;
+ scoped_ptr<Value> target_output_dir_;
+ scoped_ptr<Value> target_gen_dir_;
+ scoped_ptr<Value> relative_root_output_dir_;
+ scoped_ptr<Value> relative_root_gen_dir_;
+ scoped_ptr<Value> relative_target_output_dir_;
+ scoped_ptr<Value> relative_target_gen_dir_;
+
+ DISALLOW_COPY_AND_ASSIGN(ScopePerFileProvider);
+};
+
+#endif // TOOLS_GN_SCOPE_PER_FILE_PROVIDER_H_
diff --git a/tools/gn/secondary/base/BUILD.gn b/tools/gn/secondary/base/BUILD.gn
new file mode 100644
index 0000000..2286b19
--- /dev/null
+++ b/tools/gn/secondary/base/BUILD.gn
@@ -0,0 +1,919 @@
+# found in the LICENSE file.
+
+component("base") {
+ sources = [
+ "../build/build_config.h",
+ "third_party/dmg_fp/dmg_fp.h",
+ "third_party/dmg_fp/g_fmt.cc",
+ "third_party/dmg_fp/dtoa_wrapper.cc",
+ "third_party/icu/icu_utf.cc",
+ "third_party/icu/icu_utf.h",
+ "third_party/nspr/prcpucfg.h",
+ "third_party/nspr/prcpucfg_freebsd.h",
+ "third_party/nspr/prcpucfg_linux.h",
+ "third_party/nspr/prcpucfg_mac.h",
+ "third_party/nspr/prcpucfg_nacl.h",
+ "third_party/nspr/prcpucfg_openbsd.h",
+ "third_party/nspr/prcpucfg_solaris.h",
+ "third_party/nspr/prcpucfg_win.h",
+ "third_party/nspr/prtime.cc",
+ "third_party/nspr/prtime.h",
+ "third_party/nspr/prtypes.h",
+ "third_party/xdg_mime/xdgmime.h",
+ "allocator/allocator_extension.cc",
+ "allocator/allocator_extension.h",
+ "allocator/type_profiler_control.cc",
+ "allocator/type_profiler_control.h",
+ "android/activity_status.cc",
+ "android/activity_status.h",
+ "android/base_jni_registrar.cc",
+ "android/base_jni_registrar.h",
+ "android/build_info.cc",
+ "android/build_info.h",
+ "android/cpu_features.cc",
+ "android/fifo_utils.cc",
+ "android/fifo_utils.h",
+ "android/important_file_writer_android.cc",
+ "android/important_file_writer_android.h",
+ "android/scoped_java_ref.cc",
+ "android/scoped_java_ref.h",
+ "android/jni_android.cc",
+ "android/jni_android.h",
+ "android/jni_array.cc",
+ "android/jni_array.h",
+ "android/jni_helper.cc",
+ "android/jni_helper.h",
+ "android/jni_registrar.cc",
+ "android/jni_registrar.h",
+ "android/jni_string.cc",
+ "android/jni_string.h",
+ "android/memory_pressure_listener_android.cc",
+ "android/memory_pressure_listener_android.h",
+ "android/path_service_android.cc",
+ "android/path_service_android.h",
+ "android/path_utils.cc",
+ "android/path_utils.h",
+ "android/sys_utils.cc",
+ "android/sys_utils.h",
+ "android/thread_utils.h",
+ "at_exit.cc",
+ "at_exit.h",
+ "atomic_ref_count.h",
+ "atomic_sequence_num.h",
+ "atomicops.h",
+ "atomicops_internals_gcc.h",
+ "atomicops_internals_mac.h",
+ "atomicops_internals_tsan.h",
+ "atomicops_internals_x86_gcc.cc",
+ "atomicops_internals_x86_gcc.h",
+ "atomicops_internals_x86_msvc.h",
+ "base_export.h",
+ "base_paths.cc",
+ "base_paths.h",
+ "base_paths_android.cc",
+ "base_paths_android.h",
+ "base_paths_mac.h",
+ "base_paths_mac.mm",
+ "base_paths_posix.cc",
+ "base_paths_posix.h",
+ "base_paths_win.cc",
+ "base_paths_win.h",
+ "base_switches.h",
+ "base64.cc",
+ "base64.h",
+ "basictypes.h",
+ "bind.h",
+ "bind_helpers.cc",
+ "bind_helpers.h",
+ "bind_internal.h",
+ "bind_internal_win.h",
+ "bits.h",
+ "build_time.cc",
+ "build_time.h",
+ "callback.h",
+ "callback_helpers.h",
+ "callback_internal.cc",
+ "callback_internal.h",
+ "cancelable_callback.h",
+ "chromeos/chromeos_version.cc",
+ "chromeos/chromeos_version.h",
+ "command_line.cc",
+ "command_line.h",
+ "compiler_specific.h",
+ "containers/hash_tables.h",
+ "containers/linked_list.h",
+ "containers/mru_cache.h",
+ "containers/small_map.h",
+ "containers/stack_container.h",
+ "cpu.cc",
+ "cpu.h",
+ "critical_closure.h",
+ "critical_closure_ios.mm",
+ "debug/alias.cc",
+ "debug/alias.h",
+ "debug/crash_logging.cc",
+ "debug/crash_logging.h",
+ "debug/debug_on_start_win.cc",
+ "debug/debug_on_start_win.h",
+ "debug/debugger.cc",
+ "debug/debugger.h",
+ "debug/debugger_posix.cc",
+ "debug/debugger_win.cc",
+ # This file depends on files from the "allocator" target,
+ # but this target does not depend on "allocator" (see
+ # allocator.gyp for details).
+ "debug/leak_annotations.h",
+ "debug/leak_tracker.h",
+ "debug/proc_maps_linux.cc",
+ "debug/proc_maps_linux.h",
+ "debug/profiler.cc",
+ "debug/profiler.h",
+ "debug/stack_trace.cc",
+ "debug/stack_trace.h",
+ "debug/stack_trace_android.cc",
+ "debug/stack_trace_ios.mm",
+ "debug/stack_trace_posix.cc",
+ "debug/stack_trace_win.cc",
+ "debug/trace_event.h",
+ "debug/trace_event_android.cc",
+ "debug/trace_event_impl.cc",
+ "debug/trace_event_impl.h",
+ "debug/trace_event_impl_constants.cc",
+ "debug/trace_event_win.cc",
+ "deferred_sequenced_task_runner.cc",
+ "deferred_sequenced_task_runner.h",
+ "environment.cc",
+ "environment.h",
+ "file_descriptor_posix.h",
+ "file_util.cc",
+ "file_util.h",
+ "file_util_android.cc",
+ "file_util_linux.cc",
+ "file_util_mac.mm",
+ "file_util_posix.cc",
+ "file_util_win.cc",
+ "file_version_info.h",
+ "file_version_info_mac.h",
+ "file_version_info_mac.mm",
+ "file_version_info_win.cc",
+ "file_version_info_win.h",
+ "files/dir_reader_fallback.h",
+ "files/dir_reader_linux.h",
+ "files/dir_reader_posix.h",
+ "files/file_enumerator.cc",
+ "files/file_enumerator.h",
+ "files/file_enumerator_posix.cc",
+ "files/file_enumerator_win.cc",
+ "files/file_path.cc",
+ "files/file_path.h",
+ "files/file_path_constants.cc",
+ "files/file_path_watcher.cc",
+ "files/file_path_watcher.h",
+ "files/file_path_watcher_kqueue.cc",
+ "files/file_path_watcher_linux.cc",
+ "files/file_path_watcher_stub.cc",
+ "files/file_path_watcher_win.cc",
+ "files/file_util_proxy.cc",
+ "files/file_util_proxy.h",
+ "files/important_file_writer.h",
+ "files/important_file_writer.cc",
+ "files/memory_mapped_file.cc",
+ "files/memory_mapped_file.h",
+ "files/memory_mapped_file_posix.cc",
+ "files/memory_mapped_file_win.cc",
+ "files/scoped_temp_dir.cc",
+ "files/scoped_temp_dir.h",
+ "float_util.h",
+ "format_macros.h",
+ "gtest_prod_util.h",
+ "guid.cc",
+ "guid.h",
+ "guid_posix.cc",
+ "guid_win.cc",
+ "hash.cc",
+ "hash.h",
+ "id_map.h",
+ "ini_parser.cc",
+ "ini_parser.h",
+ "ios/device_util.h",
+ "ios/device_util.mm",
+ "ios/ios_util.h",
+ "ios/ios_util.mm",
+ "ios/scoped_critical_action.h",
+ "ios/scoped_critical_action.mm",
+ "json/json_file_value_serializer.cc",
+ "json/json_file_value_serializer.h",
+ "json/json_parser.cc",
+ "json/json_parser.h",
+ "json/json_reader.cc",
+ "json/json_reader.h",
+ "json/json_string_value_serializer.cc",
+ "json/json_string_value_serializer.h",
+ "json/json_value_converter.h",
+ "json/json_writer.cc",
+ "json/json_writer.h",
+ "json/string_escape.cc",
+ "json/string_escape.h",
+ "lazy_instance.cc",
+ "lazy_instance.h",
+ "location.cc",
+ "location.h",
+ "logging.cc",
+ "logging.h",
+ "logging_win.cc",
+ "logging_win.h",
+ "mac/authorization_util.h",
+ "mac/authorization_util.mm",
+ "mac/bind_objc_block.h",
+ "mac/bundle_locations.h",
+ "mac/bundle_locations.mm",
+ "mac/cocoa_protocols.h",
+ "mac/foundation_util.h",
+ "mac/foundation_util.mm",
+ "mac/launch_services_util.cc",
+ "mac/launch_services_util.h",
+ "mac/launchd.cc",
+ "mac/launchd.h",
+ "mac/libdispatch_task_runner.cc",
+ "mac/libdispatch_task_runner.h",
+ "mac/mac_logging.h",
+ "mac/mac_logging.cc",
+ "mac/mac_util.h",
+ "mac/mac_util.mm",
+ "mac/objc_property_releaser.h",
+ "mac/objc_property_releaser.mm",
+ "mac/os_crash_dumps.cc",
+ "mac/os_crash_dumps.h",
+ "mac/scoped_aedesc.h",
+ "mac/scoped_authorizationref.h",
+ "mac/scoped_block.h",
+ "mac/scoped_cftyperef.h",
+ "mac/scoped_ioobject.h",
+ "mac/scoped_ioplugininterface.h",
+ "mac/scoped_launch_data.h",
+ "mac/scoped_mach_port.cc",
+ "mac/scoped_mach_port.h",
+ "mac/scoped_nsautorelease_pool.h",
+ "mac/scoped_nsautorelease_pool.mm",
+ "mac/scoped_nsexception_enabler.h",
+ "mac/scoped_nsexception_enabler.mm",
+ "mac/scoped_nsobject.h",
+ "mac/scoped_sending_event.h",
+ "mac/scoped_sending_event.mm",
+ "mac/sdk_forward_declarations.h",
+ "memory/aligned_memory.cc",
+ "memory/aligned_memory.h",
+ "memory/discardable_memory.cc",
+ "memory/discardable_memory.h",
+ "memory/discardable_memory_android.cc",
+ "memory/discardable_memory_mac.cc",
+ "memory/linked_ptr.h",
+ "memory/manual_constructor.h",
+ "memory/memory_pressure_listener.cc",
+ "memory/memory_pressure_listener.h",
+ "memory/raw_scoped_refptr_mismatch_checker.h",
+ "memory/ref_counted.cc",
+ "memory/ref_counted.h",
+ "memory/ref_counted_delete_on_message_loop.h",
+ "memory/ref_counted_memory.cc",
+ "memory/ref_counted_memory.h",
+ "memory/scoped_handle.h",
+ "memory/scoped_open_process.h",
+ "memory/scoped_policy.h",
+ "memory/scoped_ptr.h",
+ "memory/scoped_vector.h",
+ "memory/shared_memory.h",
+ "memory/shared_memory_android.cc",
+ "memory/shared_memory_nacl.cc",
+ "memory/shared_memory_posix.cc",
+ "memory/shared_memory_win.cc",
+ "memory/singleton.cc",
+ "memory/singleton.h",
+ "memory/weak_ptr.cc",
+ "memory/weak_ptr.h",
+ "message_loop/message_loop.cc",
+ "message_loop/message_loop.h",
+ "message_loop/message_loop_proxy.cc",
+ "message_loop/message_loop_proxy.h",
+ "message_loop/message_loop_proxy_impl.cc",
+ "message_loop/message_loop_proxy_impl.h",
+ "message_loop/message_pump.cc",
+ "message_loop/message_pump.h",
+ "message_loop/message_pump_android.cc",
+ "message_loop/message_pump_android.h",
+ "message_loop/message_pump_default.cc",
+ "message_loop/message_pump_default.h",
+ "message_loop/message_pump_ozone.cc",
+ "message_loop/message_pump_ozone.h",
+ "message_loop/message_pump_win.cc",
+ "message_loop/message_pump_win.h",
+ "metrics/sample_map.cc",
+ "metrics/sample_map.h",
+ "metrics/sample_vector.cc",
+ "metrics/sample_vector.h",
+ "metrics/bucket_ranges.cc",
+ "metrics/bucket_ranges.h",
+ "metrics/histogram.cc",
+ "metrics/histogram.h",
+ "metrics/histogram_base.cc",
+ "metrics/histogram_base.h",
+ "metrics/histogram_flattener.h",
+ "metrics/histogram_samples.cc",
+ "metrics/histogram_samples.h",
+ "metrics/histogram_snapshot_manager.cc",
+ "metrics/histogram_snapshot_manager.h",
+ "metrics/sparse_histogram.cc",
+ "metrics/sparse_histogram.h",
+ "metrics/statistics_recorder.cc",
+ "metrics/statistics_recorder.h",
+ "metrics/stats_counters.cc",
+ "metrics/stats_counters.h",
+ "metrics/stats_table.cc",
+ "metrics/stats_table.h",
+ "move.h",
+ "native_library.h",
+ "native_library_mac.mm",
+ "native_library_posix.cc",
+ "native_library_win.cc",
+ "nix/mime_util_xdg.cc",
+ "nix/mime_util_xdg.h",
+ "nix/xdg_util.cc",
+ "nix/xdg_util.h",
+ "observer_list.h",
+ "observer_list_threadsafe.h",
+ "os_compat_android.cc",
+ "os_compat_android.h",
+ "os_compat_nacl.cc",
+ "os_compat_nacl.h",
+ "path_service.cc",
+ "path_service.h",
+ "pending_task.cc",
+ "pending_task.h",
+ "pickle.cc",
+ "pickle.h",
+ "platform_file.cc",
+ "platform_file.h",
+ "platform_file_posix.cc",
+ "platform_file_win.cc",
+ "port.h",
+ "posix/eintr_wrapper.h",
+ "posix/global_descriptors.cc",
+ "posix/global_descriptors.h",
+ "posix/unix_domain_socket_linux.cc",
+ "posix/unix_domain_socket_linux.h",
+ "power_monitor/power_monitor.cc",
+ "power_monitor/power_monitor.h",
+ "power_monitor/power_monitor_android.cc",
+ "power_monitor/power_monitor_android.h",
+ "power_monitor/power_monitor_ios.mm",
+ "power_monitor/power_monitor_mac.mm",
+ "power_monitor/power_monitor_posix.cc",
+ "power_monitor/power_monitor_win.cc",
+ "power_monitor/power_observer.h",
+ "process.h",
+ "process_info.h",
+ "process_info_mac.cc",
+ "process_info_win.cc",
+ "process_linux.cc",
+ "process_posix.cc",
+ "process_util.h",
+ "process_win.cc",
+ "process/internal_linux.cc",
+ "process/internal_linux.h",
+ "process/kill.cc",
+ "process/kill.h",
+ "process/kill_mac.cc",
+ "process/kill_posix.cc",
+ "process/kill_win.cc",
+ "process/launch.h",
+ "process/launch_ios.cc",
+ "process/launch_mac.cc",
+ "process/launch_posix.cc",
+ "process/launch_win.cc",
+ "process/memory.h",
+ "process/memory_linux.cc",
+ "process/memory_mac.mm",
+ "process/memory_win.cc",
+ "process/process_handle_freebsd.cc",
+ "process/process_handle_linux.cc",
+ "process/process_handle_mac.cc",
+ "process/process_handle_openbsd.cc",
+ "process/process_handle_posix.cc",
+ "process/process_handle_win.cc",
+ "process/process_iterator.cc",
+ "process/process_iterator.h",
+ "process/process_iterator_freebsd.cc",
+ "process/process_iterator_linux.cc",
+ "process/process_iterator_mac.cc",
+ "process/process_iterator_openbsd.cc",
+ "process/process_iterator_win.cc",
+ "process/process_metrics.h",
+ "process/process_metrics_freebsd.cc",
+ "process/process_metrics_ios.cc",
+ "process/process_metrics_linux.cc",
+ "process/process_metrics_mac.cc",
+ "process/process_metrics_openbsd.cc",
+ "process/process_metrics_posix.cc",
+ "process/process_metrics_win.cc",
+ "profiler/scoped_profile.cc",
+ "profiler/scoped_profile.h",
+ "profiler/alternate_timer.cc",
+ "profiler/alternate_timer.h",
+ "profiler/tracked_time.cc",
+ "profiler/tracked_time.h",
+ "rand_util.cc",
+ "rand_util.h",
+ "rand_util_nacl.cc",
+ "rand_util_posix.cc",
+ "rand_util_win.cc",
+ "run_loop.cc",
+ "run_loop.h",
+ "safe_numerics.h",
+ "safe_strerror_posix.cc",
+ "safe_strerror_posix.h",
+ "scoped_native_library.cc",
+ "scoped_native_library.h",
+ "sequence_checker.h",
+ "sequence_checker_impl.cc",
+ "sequence_checker_impl.h",
+ "sequenced_task_runner.cc",
+ "sequenced_task_runner.h",
+ "sequenced_task_runner_helpers.h",
+ "sha1.h",
+ "sha1_portable.cc",
+ "sha1_win.cc",
+ "single_thread_task_runner.h",
+ "stl_util.h",
+ "strings/latin1_string_conversions.cc",
+ "strings/latin1_string_conversions.h",
+ "strings/nullable_string16.cc",
+ "strings/nullable_string16.h",
+ "strings/string16.cc",
+ "strings/string16.h",
+ "strings/string_number_conversions.cc",
+ "strings/string_split.cc",
+ "strings/string_split.h",
+ "strings/string_number_conversions.h",
+ "strings/string_piece.cc",
+ "strings/string_piece.h",
+ "strings/string_tokenizer.h",
+ "strings/string_util.cc",
+ "strings/string_util.h",
+ "strings/string_util_constants.cc",
+ "strings/string_util_posix.h",
+ "strings/string_util_win.h",
+ "strings/stringize_macros.h",
+ "strings/stringprintf.cc",
+ "strings/stringprintf.h",
+ "strings/sys_string_conversions.h",
+ "strings/sys_string_conversions_mac.mm",
+ "strings/sys_string_conversions_posix.cc",
+ "strings/sys_string_conversions_win.cc",
+ "strings/utf_offset_string_conversions.cc",
+ "strings/utf_offset_string_conversions.h",
+ "strings/utf_string_conversion_utils.cc",
+ "strings/utf_string_conversion_utils.h",
+ "strings/utf_string_conversions.cc",
+ "strings/utf_string_conversions.h",
+ "supports_user_data.cc",
+ "supports_user_data.h",
+ "synchronization/cancellation_flag.cc",
+ "synchronization/cancellation_flag.h",
+ "synchronization/condition_variable.h",
+ "synchronization/condition_variable_posix.cc",
+ "synchronization/condition_variable_win.cc",
+ "synchronization/lock.cc",
+ "synchronization/lock.h",
+ "synchronization/lock_impl.h",
+ "synchronization/lock_impl_posix.cc",
+ "synchronization/lock_impl_win.cc",
+ "synchronization/spin_wait.h",
+ "synchronization/waitable_event.h",
+ "synchronization/waitable_event_posix.cc",
+ "synchronization/waitable_event_watcher.h",
+ "synchronization/waitable_event_watcher_posix.cc",
+ "synchronization/waitable_event_watcher_win.cc",
+ "synchronization/waitable_event_win.cc",
+ "system_monitor/system_monitor.cc",
+ "system_monitor/system_monitor.h",
+ "sys_byteorder.h",
+ "sys_info.cc",
+ "sys_info.h",
+ "sys_info_android.cc",
+ "sys_info_chromeos.cc",
+ "sys_info_freebsd.cc",
+ "sys_info_ios.mm",
+ "sys_info_linux.cc",
+ "sys_info_mac.cc",
+ "sys_info_openbsd.cc",
+ "sys_info_posix.cc",
+ "sys_info_win.cc",
+ "task_runner.cc",
+ "task_runner.h",
+ "task_runner_util.h",
+ "template_util.h",
+ "thread_task_runner_handle.cc",
+ "thread_task_runner_handle.h",
+ "threading/non_thread_safe.h",
+ "threading/non_thread_safe_impl.cc",
+ "threading/non_thread_safe_impl.h",
+ "threading/platform_thread.h",
+ "threading/platform_thread_android.cc",
+ "threading/platform_thread_linux.cc",
+ "threading/platform_thread_mac.mm",
+ "threading/platform_thread_posix.cc",
+ "threading/platform_thread_win.cc",
+ "threading/post_task_and_reply_impl.cc",
+ "threading/post_task_and_reply_impl.h",
+ "threading/sequenced_worker_pool.cc",
+ "threading/sequenced_worker_pool.h",
+ "threading/simple_thread.cc",
+ "threading/simple_thread.h",
+ "threading/thread.cc",
+ "threading/thread.h",
+ "threading/thread_checker.h",
+ "threading/thread_checker_impl.cc",
+ "threading/thread_checker_impl.h",
+ "threading/thread_collision_warner.cc",
+ "threading/thread_collision_warner.h",
+ "threading/thread_id_name_manager.cc",
+ "threading/thread_id_name_manager.h",
+ "threading/thread_local.h",
+ "threading/thread_local_posix.cc",
+ "threading/thread_local_storage.h",
+ "threading/thread_local_storage_posix.cc",
+ "threading/thread_local_storage_win.cc",
+ "threading/thread_local_win.cc",
+ "threading/thread_restrictions.h",
+ "threading/thread_restrictions.cc",
+ "threading/watchdog.cc",
+ "threading/watchdog.h",
+ "threading/worker_pool.h",
+ "threading/worker_pool.cc",
+ "threading/worker_pool_posix.cc",
+ "threading/worker_pool_posix.h",
+ "threading/worker_pool_win.cc",
+ "time/clock.cc",
+ "time/clock.h",
+ "time/default_clock.cc",
+ "time/default_clock.h",
+ "time/default_tick_clock.cc",
+ "time/default_tick_clock.h",
+ "time/tick_clock.cc",
+ "time/tick_clock.h",
+ "time/time.cc",
+ "time/time.h",
+ "time/time_mac.cc",
+ "time/time_posix.cc",
+ "time/time_win.cc",
+ "timer/hi_res_timer_manager_posix.cc",
+ "timer/hi_res_timer_manager_win.cc",
+ "timer/hi_res_timer_manager.h",
+ "timer/timer.cc",
+ "timer/timer.h",
+ "tracked_objects.cc",
+ "tracked_objects.h",
+ "tracking_info.cc",
+ "tracking_info.h",
+ "tuple.h",
+ "values.cc",
+ "values.h",
+ "value_conversions.cc",
+ "value_conversions.h",
+ "version.cc",
+ "version.h",
+ "vlog.cc",
+ "vlog.h",
+ "win/enum_variant.cc",
+ "win/enum_variant.h",
+ "win/event_trace_consumer.h",
+ "win/event_trace_controller.cc",
+ "win/event_trace_controller.h",
+ "win/event_trace_provider.cc",
+ "win/event_trace_provider.h",
+ "win/i18n.cc",
+ "win/i18n.h",
+ "win/iat_patch_function.cc",
+ "win/iat_patch_function.h",
+ "win/iunknown_impl.cc",
+ "win/iunknown_impl.h",
+ "win/message_window.cc",
+ "win/message_window.h",
+ "win/metro.cc",
+ "win/metro.h",
+ "win/object_watcher.cc",
+ "win/object_watcher.h",
+ "win/registry.cc",
+ "win/registry.h",
+ "win/resource_util.cc",
+ "win/resource_util.h",
+ "win/sampling_profiler.cc",
+ "win/sampling_profiler.h",
+ "win/scoped_bstr.cc",
+ "win/scoped_bstr.h",
+ "win/scoped_co_mem.h",
+ "win/scoped_com_initializer.h",
+ "win/scoped_comptr.h",
+ "win/scoped_gdi_object.h",
+ "win/scoped_handle.cc",
+ "win/scoped_handle.h",
+ "win/scoped_hdc.h",
+ "win/scoped_hglobal.h",
+ "win/scoped_process_information.cc",
+ "win/scoped_process_information.h",
+ "win/scoped_propvariant.h",
+ "win/scoped_select_object.h",
+ "win/scoped_variant.cc",
+ "win/scoped_variant.h",
+ "win/shortcut.cc",
+ "win/shortcut.h",
+ "win/startup_information.cc",
+ "win/startup_information.h",
+ "win/text_services_message_filter.cc",
+ "win/text_services_message_filter.h",
+ "win/win_util.cc",
+ "win/win_util.h",
+ "win/windows_version.cc",
+ "win/windows_version.h",
+ "win/wrapped_window_proc.cc",
+ "win/wrapped_window_proc.h",
+ ]
+
+ # TODO(brettw) I don't understand the conditions this file is used.
+ sources -= "files/file_path_watcher_stub.cc"
+
+ sources -= [
+ # TODO(brettw) ozone
+ "message_loop/message_pump_ozone.cc",
+ "message_loop/message_pump_ozone.h",
+
+ "process/process_handle_freebsd.cc",
+ "process/process_handle_openbsd.cc",
+ "process/process_iterator_freebsd.cc",
+ "process/process_iterator_openbsd.cc",
+ "process/process_metrics_freebsd.cc",
+ "process/process_metrics_openbsd.cc",
+ "sys_info_freebsd.cc",
+ "sys_info_openbsd.cc",
+ ]
+
+ if (!is_chromeos) {
+ sources -= [
+ "sys_info_chromeos.cc",
+ ]
+ }
+ if (!is_mac) {
+ sources -= "files/file_path_watcher_kqueue.cc"
+ }
+
+ # Remove nacl stuff.
+ if (!is_nacl) {
+ sources -= [
+ "os_compat_nacl.cc",
+ "os_compat_nacl.h",
+ "rand_util_nacl.cc",
+ "third_party/nspr/prcpucfg_nacl.h",
+ "memory/shared_memory_nacl.cc",
+ ]
+ }
+
+ # Windows stuff.
+ if (is_win && !is_nacl) {
+ sources -= [
+ "strings/string16.cc",
+ # Not using sha1_win.cc because it may have caused a
+ # regression to page cycler moz.
+ "sha1_win.cc",
+ ]
+
+ if (is_component_build) {
+ sources -= "debug/debug_on_start_win.cc"
+ }
+ }
+
+ # Remove non-Mac Unix stuff.
+ if (!is_posix || is_mac) {
+ sources -= [
+ "nix/mime_util_xdg.cc",
+ "nix/mime_util_xdg.h",
+ "nix/xdg_util.cc",
+ "nix/xdg_util.h",
+ ]
+ }
+
+ defines = [
+ "BASE_IMPLEMENTATION",
+ ]
+
+ deps = [
+ ":base_static",
+ "//base/allocator:allocator_extension_thunks",
+ "//third_party/modp_b64",
+ "//base/third_party/dynamic_annotations",
+ ]
+}
+
+# This is the subset of files from base that should not be used with a dynamic
+# library. Note that this library cannot depend on base because base depends on
+# base_static.
+static_library("base_static") {
+ sources = [
+ "base_switches.cc",
+ "base_switches.h",
+ "win/pe_image.cc",
+ "win/pe_image.h",
+ ]
+}
+
+component("base_i18n") {
+ sources = [
+ "i18n/base_i18n_export.h",
+ "i18n/bidi_line_iterator.cc",
+ "i18n/bidi_line_iterator.h",
+ "i18n/break_iterator.cc",
+ "i18n/break_iterator.h",
+ "i18n/char_iterator.cc",
+ "i18n/char_iterator.h",
+ "i18n/case_conversion.cc",
+ "i18n/case_conversion.h",
+ "i18n/file_util_icu.cc",
+ "i18n/file_util_icu.h",
+ "i18n/icu_encoding_detection.cc",
+ "i18n/icu_encoding_detection.h",
+ "i18n/icu_string_conversions.cc",
+ "i18n/icu_string_conversions.h",
+ "i18n/icu_util.cc",
+ "i18n/icu_util.h",
+ "i18n/number_formatting.cc",
+ "i18n/number_formatting.h",
+ "i18n/rtl.cc",
+ "i18n/rtl.h",
+ "i18n/string_compare.cc",
+ "i18n/string_compare.h",
+ "i18n/string_search.cc",
+ "i18n/string_search.h",
+ "i18n/time_formatting.cc",
+ "i18n/time_formatting.h",
+ ]
+ deps = [
+ ":base",
+ "//base/third_party/dynamic_annotations",
+ "//third_party/icu:icui18n",
+ "//third_party/icu:icuuc",
+ ]
+ defines = [
+ "BASE_I18N_IMPLEMENTATION",
+ ]
+ #'conditions': [
+ # ['toolkit_uses_gtk==1', {
+ # 'deps': [
+ # # i18n/rtl.cc uses gtk
+ # '../build/linux/system.gyp:gtk',
+ # ],
+ # }],
+ # ['OS == "win"', {
+ # # TODO(jschuh): crbug.com/167187 fix size_t to int truncations.
+ # 'msvs_disabled_warnings': [
+ # 4267,
+ # ],
+ # }],
+ #],
+ #'export_dependent_settings': [
+ # 'base',
+ #],
+ #'variables': {
+ # 'enable_wexit_time_destructors': 1,
+ # 'optimize': 'max',
+ #},
+}
+
+static_library("test_support_base") {
+ sources = [
+ "perftimer.cc",
+ "test/expectations/expectation.cc",
+ "test/expectations/expectation.h",
+ "test/expectations/parser.cc",
+ "test/expectations/parser.h",
+ "test/mock_chrome_application_mac.h",
+ "test/mock_chrome_application_mac.mm",
+ "test/mock_devices_changed_observer.cc",
+ "test/mock_devices_changed_observer.h",
+ "test/mock_time_provider.cc",
+ "test/mock_time_provider.h",
+ "test/multiprocess_test.cc",
+ "test/multiprocess_test.h",
+ "test/multiprocess_test_android.cc",
+ "test/null_task_runner.cc",
+ "test/null_task_runner.h",
+ "test/perf_test_suite.cc",
+ "test/perf_test_suite.h",
+ "test/scoped_locale.cc",
+ "test/scoped_locale.h",
+ "test/scoped_path_override.cc",
+ "test/scoped_path_override.h",
+ "test/sequenced_task_runner_test_template.cc",
+ "test/sequenced_task_runner_test_template.h",
+ "test/sequenced_worker_pool_owner.cc",
+ "test/sequenced_worker_pool_owner.h",
+ "test/simple_test_clock.cc",
+ "test/simple_test_clock.h",
+ "test/simple_test_tick_clock.cc",
+ "test/simple_test_tick_clock.h",
+ "test/task_runner_test_template.cc",
+ "test/task_runner_test_template.h",
+ "test/test_file_util.h",
+ "test/test_file_util_linux.cc",
+ "test/test_file_util_mac.cc",
+ "test/test_file_util_posix.cc",
+ "test/test_file_util_win.cc",
+ "test/test_listener_ios.h",
+ "test/test_listener_ios.mm",
+ "test/test_pending_task.cc",
+ "test/test_pending_task.h",
+ "test/test_process_killer_win.cc",
+ "test/test_process_killer_win.h",
+ "test/test_reg_util_win.cc",
+ "test/test_reg_util_win.h",
+ "test/test_shortcut_win.cc",
+ "test/test_shortcut_win.h",
+ "test/test_simple_task_runner.cc",
+ "test/test_simple_task_runner.h",
+ "test/test_suite.cc",
+ "test/test_suite.h",
+ "test/test_support_android.cc",
+ "test/test_support_android.h",
+ "test/test_support_ios.h",
+ "test/test_support_ios.mm",
+ "test/test_switches.cc",
+ "test/test_switches.h",
+ "test/test_timeouts.cc",
+ "test/test_timeouts.h",
+ "test/thread_test_helper.cc",
+ "test/thread_test_helper.h",
+ "test/trace_event_analyzer.cc",
+ "test/trace_event_analyzer.h",
+ "test/values_test_util.cc",
+ "test/values_test_util.h",
+ ]
+ deps = [
+ ":base",
+ ":base_static",
+ ":base_i18n",
+ "//testing:gmock",
+ "//testing:gtest",
+ ]
+
+ if (!is_posix) {
+ sources -= [
+ "test/scoped_locale.cc",
+ "test/scoped_locale.h",
+ ]
+ }
+ if (is_ios) {
+ # Pull in specific Mac files for iOS (which have been filtered out
+ # by file name rules).
+ { # Temporarily override the assignment filter in a new scope.
+ set_sources_assignment_filter([])
+ sources += "test/test_file_util_mac.cc"
+ }
+ }
+ #if (!is_bsd) {
+ # sources -= "test/test_file_util_linux.cc"
+ #}
+ #if (use_gtk) {
+ # deps += "/build/linux/system:gtk"
+ #}
+ #export_dependent_settings [
+ # 'base',
+ #]
+}
+
+config("perf_test_config") {
+ defines = [ "PERF_TEST" ]
+}
+
+static_library("test_support_perf") {
+ sources = [
+ "perftimer.cc",
+ "test/run_all_perftests.cc",
+ ]
+ deps = [
+ ":base",
+ "//testing:gtest",
+ ]
+
+ direct_dependent_configs = [ ":perf_test_config" ]
+
+ #if (toolkit_uses_gtk) {
+ # deps += "/build/linux/system:gtk",
+ #}
+}
+
+static_library("run_all_unittests") {
+ sources = [
+ "test/run_all_unittests.cc",
+ ]
+ deps = [
+ ":test_support_base",
+ ]
+}
diff --git a/tools/gn/secondary/base/allocator/BUILD.gn b/tools/gn/secondary/base/allocator/BUILD.gn
new file mode 100644
index 0000000..bbcfe65
--- /dev/null
+++ b/tools/gn/secondary/base/allocator/BUILD.gn
@@ -0,0 +1,6 @@
+static_library("allocator_extension_thunks") {
+ sources = [
+ "allocator_extension_thunks.cc",
+ "allocator_extension_thunks.h",
+ ]
+}
diff --git a/tools/gn/secondary/base/third_party/dynamic_annotations/BUILD.gn b/tools/gn/secondary/base/third_party/dynamic_annotations/BUILD.gn
new file mode 100644
index 0000000..e3939c3
--- /dev/null
+++ b/tools/gn/secondary/base/third_party/dynamic_annotations/BUILD.gn
@@ -0,0 +1,7 @@
+static_library("dynamic_annotations") {
+ sources = [
+ "dynamic_annotations.c",
+ "dynamic_annotations.h",
+ "../valgrind/valgrind.h",
+ ]
+}
diff --git a/tools/gn/secondary/build/config/BUILD.gn b/tools/gn/secondary/build/config/BUILD.gn
new file mode 100644
index 0000000..74c57af
--- /dev/null
+++ b/tools/gn/secondary/build/config/BUILD.gn
@@ -0,0 +1,52 @@
+config("my_msvs") {
+ includes = [ "../.." ]
+ cflags = [
+ "/Od", "/WX", "/Zi", "/Gy", "/GS", "/RTC1", "/EHsc",
+ ]
+ defines = [
+ "CHROMIUM_BUILD",
+ "TOOLKIT_VIEWS=1",
+ "USE_LIBJPEG_TURBO=1",
+ "ENABLE_ONE_CLICK_SIGNIN",
+ "ENABLE_REMOTING=1",
+ "ENABLE_WEBRTC=1",
+ "ENABLE_CONFIGURATION_POLICY",
+ "ENABLE_INPUT_SPEECH",
+ "ENABLE_NOTIFICATIONS",
+ "ENABLE_GPU=1",
+ "ENABLE_EGLIMAGE=1",
+ "ENABLE_TASK_MANAGER=1",
+ "ENABLE_EXTENSIONS=1",
+ "ENABLE_PLUGIN_INSTALLATION=1",
+ "ENABLE_PLUGINS=1",
+ "ENABLE_SESSION_SERVICE=1",
+ "ENABLE_THEMES=1",
+ "ENABLE_AUTOFILL_DIALOG=1",
+ "ENABLE_BACKGROUND=1",
+ "ENABLE_AUTOMATION=1",
+ "ENABLE_GOOGLE_NOW=1",
+ "ENABLE_LANGUAGE_DETECTION=1",
+ "ENABLE_PRINTING=1",
+ "ENABLE_CAPTIVE_PORTAL_DETECTION=1",
+ "ENABLE_APP_LIST=1",
+ "ENABLE_MESSAGE_CENTER=1",
+ "ENABLE_SETTINGS_APP=1",
+ "ENABLE_MANAGED_USERS=1",
+ ]
+}
+
+config("feature_flags") {
+ #defines =
+}
+
+config("debug") {
+ defines = [
+ "_DEBUG",
+ "DYNAMIC_ANNOTATIONS_ENABLED=1",
+ "WTF_USE_DYNAMIC_ANNOTATIONS=1",
+ ]
+}
+
+config("release") {
+
+}
diff --git a/tools/gn/secondary/build/config/BUILDCONFIG.gn b/tools/gn/secondary/build/config/BUILDCONFIG.gn
new file mode 100644
index 0000000..0245597
--- /dev/null
+++ b/tools/gn/secondary/build/config/BUILDCONFIG.gn
@@ -0,0 +1,187 @@
+# =============================================================================
+# BUILD FLAGS
+# =============================================================================
+#
+# This block lists input arguments to the build, along with their default
+# values. GN requires listing them explicitly so it can validate input and have
+# a central place to manage the build flags.
+#
+# If a value is specified on the command line, it will overwrite the defaults
+# given here, otherwise the default will be injected into the root scope.
+#
+# KEEP IN ALPHABETICAL ORDER and write a good description for everything.
+# Use "is_*" names for intrinsic platform descriptions and build modes, and
+# "use_*" names for optional features libraries, and configurations.
+declare_args() {
+ is_component_build = 1
+ is_chromeos = 0
+ is_debug = 1
+ use_ash = 0
+ use_aura = 0
+ use_ozone = 0
+}
+
+# =============================================================================
+# SOURCES FILTERS
+# =============================================================================
+#
+# These patterns filter out platform-specific files when assigning to the
+# sources variable. The magic variable |sources_assignment_filter| is applied
+# to each assignment or appending to the sources variable and matches are
+# automatcally removed.
+#
+# We define lists of filters for each platform for all builds so they can
+# be used by individual targets if necessary (a target can always change
+# sources_assignment_filter on itself if it needs something more specific).
+#
+# Note that the patterns are NOT regular expressions. Only "*" and "\b" (path
+# boundary = end of string or slash) are supported, and the entire string
+# muct match the pattern (so you need "*.cc" to match all .cc files, for
+# example).
+
+windows_sources_filters = [
+ "*_win.cc",
+ "*_win.h",
+ "*_win_unittest.cc",
+ "*\bwin/*",
+]
+mac_sources_filters = [
+ "*_mac.h",
+ "*_mac.cc",
+ "*_mac.mm",
+ "*_mac_unittest.h",
+ "*_mac_unittest.cc",
+ "*_mac_unittest.mm",
+ "*\bmac/*",
+ "*_cocoa.h",
+ "*_cocoa.cc",
+ "*_cocoa.mm",
+ "*_cocoa_unittest.h",
+ "*_cocoa_unittest.cc",
+ "*_cocoa_unittest.mm",
+ "*\bcocoa/*",
+]
+ios_sources_filters = [
+ "*_ios.h",
+ "*_ios.cc",
+ "*_ios.mm",
+ "*_ios_unittest.h",
+ "*_ios_unittest.cc",
+ "*_ios_unittest.mm",
+ "*\bios/*",
+]
+objective_c_sources_filters = [
+ "*.mm",
+]
+linux_sources_filters = [
+ "*_linux.h",
+ "*_linux.cc",
+ "*_linux_unittest.h",
+ "*_linux_unittest.cc",
+ "*\blinux/*",
+]
+android_sources_filters = [
+ "*_android.h",
+ "*_android.cc",
+ "*_android_unittest.h",
+ "*_android_unittest.cc",
+ "*\bandroid/*",
+]
+posix_sources_filters = [
+ "*_posix.h",
+ "*_posix.cc",
+ "*_posix_unittest.h",
+ "*_posix_unittest.cc",
+ "*\bposix/*",
+]
+
+# Construct the full list of sources we're using for this platform.
+sources_assignment_filter = []
+if (is_win) {
+ sources_assignment_filter += posix_sources_filters
+} else {
+ sources_assignment_filter += windows_sources_filters
+}
+if (!is_mac) {
+ sources_assignment_filter += mac_sources_filters
+}
+if (!is_ios) {
+ sources_assignment_filter += ios_sources_filters
+}
+if (!is_mac && !is_ios) {
+ sources_assignment_filter += objective_c_sources_filters
+}
+if (!is_linux) {
+ sources_assignment_filter += linux_sources_filters
+}
+if (!is_android) {
+ sources_assignment_filter += android_sources_filters
+}
+
+# This is the actual set.
+set_sources_assignment_filter(sources_assignment_filter)
+
+# =============================================================================
+# SYSTEM CONFIG
+# =============================================================================
+
+is_nacl = 0
+
+# =============================================================================
+# BUILD OPTIONS
+# =============================================================================
+
+if (is_component_build) {
+ component_mode = "shared_library"
+} else {
+ component_mode = "static_library"
+}
+
+# =============================================================================
+# TARGET DEFAULTS
+# =============================================================================
+#
+# Set up the default configuration for every build target of the given type.
+# The values configured here will be automatically set on the scope of the
+# corresponding target. Target definitions can add or remove to the settings
+# here as needed.
+
+# Holds all configs used for making native executables and libraries, to avoid
+# duplication in each target below.
+native_compiler_configs = [
+ "//build/config:my_msvs", # TODO(brettw) eraseme
+
+ "//build/config/compiler:chromium_code",
+ "//build/config/compiler:disable_annoying_warnings",
+ "//build/config/compiler:no_rtti",
+ "//build/config/compiler:runtime_library",
+]
+if (is_win) {
+ native_compiler_configs += "//build/config/win:sdk"
+}
+
+if (is_debug) {
+ native_compiler_configs += "//build/config:debug"
+} else {
+ native_compiler_configs += "//build/config::release"
+}
+
+set_defaults("executable") {
+ configs = native_compiler_configs
+}
+
+set_defaults("static_library") {
+ configs = native_compiler_configs
+}
+
+set_defaults("shared_library") {
+ configs = native_compiler_configs
+}
+
+# ==============================================================================
+# TOOLCHAIN SETUP
+# ==============================================================================
+
+if (is_win) {
+ set_default_toolchain("//build/config/win:32")
+}
diff --git a/tools/gn/secondary/build/config/compiler/BUILD.gn b/tools/gn/secondary/build/config/compiler/BUILD.gn
new file mode 100644
index 0000000..0487828
--- /dev/null
+++ b/tools/gn/secondary/build/config/compiler/BUILD.gn
@@ -0,0 +1,134 @@
+# 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.
+
+# runtime_library -------------------------------------------------------------
+#
+# Sets the runtime library and associated options.
+#
+# We don't bother making multiple versions that are toggle-able since there
+# is more than one axis of control (which makes it complicated) and there's
+# no practical reason for anybody to change this since the CRT must agree.
+
+config("runtime_library") {
+ if (is_component_build) {
+ # Component mode: dynamic CRT.
+ defines = [ "COMPONENT_BUILD" ]
+ if (is_win) {
+ # Since the library is shared, it requires exceptions or will give errors
+ # about things not matching, so keep exceptions on.
+ if (is_debug) {
+ cflags = [ "/MDd" ]
+ } else {
+ cflags = [ "/MD" ]
+ }
+ }
+ } else {
+ # Static CRT.
+ if (is_win) {
+ # We don't use exceptions, and when we link statically we can just get
+ # rid of them entirely.
+ defines = [ "_HAS_EXCEPTIONS=0" ]
+ if (is_debug) {
+ cflags = [ "/MTd" ]
+ } else {
+ cflags = [ "/MT" ]
+ }
+ }
+ }
+
+ if (is_win) {
+ defines += [
+ "__STD_C",
+ "__STDC_CONSTANT_MACROS",
+ "__STDC_FORMAT_MACROS",
+ "_CRT_RAND_S",
+ "_CRT_SECURE_NO_DEPRECATE",
+ "_SCL_SECURE_NO_DEPRECATE",
+ "_UNICODE",
+ "UNICODE",
+ ]
+ }
+}
+
+# chromium_code ---------------------------------------------------------------
+#
+# Toggles between higher and lower warnings for code that is (or isn't)
+# part of Chromium.
+
+config("chromium_code") {
+ if (is_win) {
+ cflags = [
+ "/W4", # Warning level 4.
+ ]
+ }
+}
+config("no_chromium_code") {
+ if (is_win) {
+ cflags = [
+ "/W3", # Warning level 3.
+ "/wd4800", # Disable warning when forcing value to bool.
+ ]
+ defines = [
+ "_CRT_NONSTDC_NO_WARNINGS",
+ "_CRT_NONSTDC_NO_DEPRECATE",
+ ]
+ }
+}
+
+# rtti ------------------------------------------------------------------------
+#
+# Allows turning Run-Time Type Identification on or off.
+
+config("rtti") {
+ if (is_win) {
+ cflags = [ "/GR" ]
+ }
+}
+config("no_rtti") {
+ if (is_win) {
+ cflags = [ "/GR-" ]
+ }
+}
+
+# Warnings ---------------------------------------------------------------------
+
+config("disable_annoying_warnings") {
+ if (is_win) {
+ # Please keep ordered and add names if you add more.
+ cflags = [
+ "/wd4018", # Comparing signed and unsigned values.
+ "/wd4100", # Unreferenced formal function parameter.
+ "/wd4121", # Alignment of a member was sensitive to packing.
+ "/wd4125", # Decimal digit terminates octal escape sequence.
+ "/wd4127", # Conditional expression is constant.
+ "/wd4130", # Logical operation on address of string constant.
+ # TODO(brettw) is this necessary? If so, it should probably be on whoever
+ # is silly enough to be doing this rather than globally.
+ #"/wd4131", # Function uses old-style declarator.
+ "/wd4189", # A variable was declared and initialized but never used.
+ "/wd4201", # Nonstandard extension used: nameless struct/union.
+ "/wd4238", # Nonstandard extension used: class rvalue used as lvalue.
+ "/wd4244", # Conversion: possible loss of data.
+ "/wd4245", # Conversion: signed/unsigned mismatch,
+ "/wd4251", # Class needs to have dll-interface.
+ "/wd4310", # Cast truncates constant value.
+ "/wd4351", # Elements of array will be default initialized.
+ "/wd4355", # 'this' used in base member initializer list.
+ "/wd4396", # Inline friend template thing.
+ "/wd4428", # Universal character name encountered in source.
+ "/wd4481", # Nonstandard extension: override specifier.
+ "/wd4503", # Decorated name length exceeded, name was truncated.
+ "/wd4505", # Unreferenced local function has been removed.
+ "/wd4510", # Default constructor could not be generated.
+ "/wd4512", # Assignment operator could not be generated.
+ "/wd4530", # Exception handler used, but unwind semantics not enabled.
+ "/wd4610", # Class can never be instantiated, constructor required.
+ "/wd4611", # C++ object destruction and 'catch'.
+ "/wd4701", # Potentially uninitialized local variable name used.
+ "/wd4702", # Unreachable code.
+ "/wd4706", # Assignment within conditional expression.
+ "/wd4819", # Character not in the current code page.
+ ]
+ }
+}
diff --git a/tools/gn/secondary/build/config/win/BUILD.gn b/tools/gn/secondary/build/config/win/BUILD.gn
new file mode 100644
index 0000000..955504a
--- /dev/null
+++ b/tools/gn/secondary/build/config/win/BUILD.gn
@@ -0,0 +1,184 @@
+# 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.
+
+# Should only be running on Windows.
+assert(is_win)
+
+# Setup the Visual Studio state.
+#
+# Its argument is the location to write the environment files.
+# It will write "environment.x86" and "environment.x64" to this directory,
+# and return a list to us.
+#
+# The list contains the include path as its only element. (I'm expecting to
+# add more so it's currently a list inside a list.)
+msvc_config = [["foo"]]
+#exec_script("get_msvc_config.py",
+ # [relative_root_output_dir],
+ # "value")
+
+# 32-bit toolchain -------------------------------------------------------------
+
+toolchain("32") {
+ tool("cc") {
+ command = "ninja -t msvc -e \$arch -- cl.exe /nologo /showIncludes /FC @\$out.rsp /c \$in /Fo\$out /Fd\$pdbname"
+ description = "CC \$out"
+ rspfile = "\$out.rsp"
+ rspfile_content = "\$defines \$includes \$cflags \$cflags_c"
+ deps = "msvc"
+ }
+ tool("cxx") {
+ command = "ninja -t msvc -e \$arch -- cl.exe /nologo /showIncludes /FC @\$out.rsp /c \$in /Fo\$out /Fd\$pdbname"
+ description = "CXX \$out"
+ rspfile = "\$out.rsp"
+ rspfile_content = "\$defines \$includes \$cflags \$cflags_cc"
+ deps = "msvc"
+ }
+ #tool("idl") {
+ # command = $python_path gyp-win-tool midl-wrapper \$arch \$outdir \$tlb \$h \$dlldata \$iid \$
+ # \$proxy \$in \$idlflags
+ # description = IDL \$in
+ #}
+ #tool("rc") {
+ # command = $python_path gyp-win-tool rc-wrapper \$arch rc.exe \$defines \$includes \$rcflags \$
+ # /fo\$out \$in
+ # description = RC \$in
+ #}
+ #tool("asm") {
+ # command = $python_path gyp-win-tool asm-wrapper \$arch ml.exe \$defines \$includes /c /Fo \$
+ # \$out \$in
+ # description = ASM \$in
+ #}
+ tool("alink") {
+ command = "$python_path gyp-win-tool link-wrapper \$arch lib.exe /nologo /ignore:4221 /OUT:\$out @\$out.rsp"
+ description = "LIB \$out"
+ rspfile = "\$out.rsp"
+ rspfile_content = "\$in_newline \$libflags"
+ }
+ #tool("solink_embed_inc") {
+ # command = cmd /c $python_path gyp-win-tool link-wrapper \$arch link.exe /nologo \$implibflag \$
+ # /DLL /OUT:\$dll /PDB:\$dll.pdb @\$dll.rsp && $python_path gyp-win-tool \$
+ # manifest-wrapper \$arch cmd /c if exist \$dll.manifest del \$dll.manifest && \$
+ # $python_path gyp-win-tool manifest-wrapper \$arch mt.exe -nologo -manifest \$manifests \$
+ # -out:\$dll.manifest && $python_path gyp-win-tool manifest-to-rc \$arch \$dll.manifest \$
+ # \$dll.manifest.rc 2 && $python_path gyp-win-tool rc-wrapper \$arch rc.exe \$
+ # \$dll.manifest.rc && $python_path gyp-win-tool link-wrapper \$arch link.exe /nologo \$
+ # \$implibflag /DLL /OUT:\$dll /PDB:\$dll.pdb @\$dll.rsp \$dll.manifest.res
+ # description = LINK_EMBED_INC(DLL) \$dll
+ # restat = 1
+ # rspfile = \$dll.rsp
+ # rspfile_content = \$libs \$in_newline \$ldflags
+ #}
+ #tool("solink_module_embed_inc") {
+ # command = cmd /c $python_path gyp-win-tool link-wrapper \$arch link.exe /nologo \$implibflag \$
+ # /DLL /OUT:\$dll /PDB:\$dll.pdb @\$dll.rsp && $python_path gyp-win-tool \$
+ # manifest-wrapper \$arch cmd /c if exist \$dll.manifest del \$dll.manifest && \$
+ # $python_path gyp-win-tool manifest-wrapper \$arch mt.exe -nologo -manifest \$manifests \$
+ # -out:\$dll.manifest && $python_path gyp-win-tool manifest-to-rc \$arch \$dll.manifest \$
+ # \$dll.manifest.rc 2 && $python_path gyp-win-tool rc-wrapper \$arch rc.exe \$
+ # \$dll.manifest.rc && $python_path gyp-win-tool link-wrapper \$arch link.exe /nologo \$
+ # \$implibflag /DLL /OUT:\$dll /PDB:\$dll.pdb @\$dll.rsp \$dll.manifest.res
+ # description = LINK_EMBED_INC(DLL) \$dll
+ # restat = 1
+ # rspfile = \$dll.rsp
+ # rspfile_content = \$libs \$in_newline \$ldflags
+ #}
+ #rule link_embed_inc
+ # command = cmd /c $python_path gyp-win-tool link-wrapper \$arch link.exe /nologo /OUT:\$out \$
+ # /PDB:\$out.pdb @\$out.rsp && $python_path gyp-win-tool manifest-wrapper \$arch cmd /c \$
+ # if exist \$out.manifest del \$out.manifest && $python_path gyp-win-tool \$
+ # manifest-wrapper \$arch mt.exe -nologo -manifest \$manifests -out:\$out.manifest && \$
+ # $python_path gyp-win-tool manifest-to-rc \$arch \$out.manifest \$out.manifest.rc 1 && \$
+ # $python_path gyp-win-tool rc-wrapper \$arch rc.exe \$out.manifest.rc && \$
+ # $python_path gyp-win-tool link-wrapper \$arch link.exe /nologo /OUT:\$out /PDB:\$out.pdb \$
+ # @\$out.rsp \$out.manifest.res
+ # description = LINK_EMBED_INC \$out
+ # rspfile = \$out.rsp
+ # rspfile_content = \$in_newline \$libs \$ldflags
+ #rule solink_embed
+ # command = cmd /c $python_path gyp-win-tool link-wrapper \$arch link.exe /nologo \$implibflag \$
+ # /DLL /OUT:\$dll /PDB:\$dll.pdb @\$dll.rsp && $python_path gyp-win-tool \$
+ # manifest-wrapper \$arch cmd /c if exist \$dll.manifest del \$dll.manifest && \$
+ # $python_path gyp-win-tool manifest-wrapper \$arch mt.exe -nologo -manifest \$manifests \$
+ # -outputresource:\$dll;2
+ # description = LINK_EMBED(DLL) \$dll
+ # restat = 1
+ # rspfile = \$dll.rsp
+ # rspfile_content = \$libs \$in_newline \$ldflags
+ #rule solink_module_embed
+ # command = cmd /c $python_path gyp-win-tool link-wrapper \$arch link.exe /nologo \$implibflag \$
+ # /DLL /OUT:\$dll /PDB:\$dll.pdb @\$dll.rsp && $python_path gyp-win-tool \$
+ # manifest-wrapper \$arch cmd /c if exist \$dll.manifest del \$dll.manifest && \$
+ # $python_path gyp-win-tool manifest-wrapper \$arch mt.exe -nologo -manifest \$manifests \$
+ # -outputresource:\$dll;2
+ # description = LINK_EMBED(DLL) \$dll
+ # restat = 1
+ # rspfile = \$dll.rsp
+ # rspfile_content = \$libs \$in_newline \$ldflags
+ #rule link_embed
+ # command = cmd /c $python_path gyp-win-tool link-wrapper \$arch link.exe /nologo /OUT:\$out \$
+ # /PDB:\$out.pdb @\$out.rsp && $python_path gyp-win-tool manifest-wrapper \$arch cmd /c \$
+ # if exist \$out.manifest del \$out.manifest && $python_path gyp-win-tool \$
+ # manifest-wrapper \$arch mt.exe -nologo -manifest \$manifests -outputresource:\$out;1
+ # description = LINK_EMBED \$out
+ # rspfile = \$out.rsp
+ # rspfile_content = \$in_newline \$libs \$ldflags
+ tool("solink") {
+ command = "cmd /c $python_path gyp-win-tool link-wrapper \$arch link.exe /nologo \$implibflag /DLL /OUT:\$dll /PDB:\$dll.pdb @\$dll.rsp && $python_path gyp-win-tool manifest-wrapper \$arch cmd /c if exist \$dll.manifest del \$dll.manifest && $python_path gyp-win-tool manifest-wrapper \$arch mt.exe -nologo -manifest \$manifests -out:\$dll.manifest"
+ description = "LINK(DLL) \$dll"
+ restat = "1"
+ rspfile = "\$dll.rsp"
+ rspfile_content = "\$libs \$in_newline \$ldflags"
+ }
+ tool("solink_module") {
+ command = "cmd /c $python_path gyp-win-tool link-wrapper \$arch link.exe /nologo \$implibflag /DLL /OUT:\$dll /PDB:\$dll.pdb @\$dll.rsp && $python_path gyp-win-tool manifest-wrapper \$arch cmd /c if exist \$dll.manifest del \$dll.manifest && $python_path gyp-win-tool manifest-wrapper \$arch mt.exe -nologo -manifest \$manifests -out:\$dll.manifet"
+ description = "LINK(DLL) \$dll"
+ restat = "1"
+ rspfile = "\$dll.rsp"
+ rspfile_content = "\$libs \$in_newline \$ldflags"
+ }
+ tool("link") {
+ command = "cmd /c $python_path gyp-win-tool link-wrapper \$arch link.exe /nologo /OUT:\$out /PDB:\$out.pdb @\$out.rsp && $python_path gyp-win-tool manifest-wrapper \$arch cmd /c if exist \$out.manifest del \$out.manifest && $python_path gyp-win-tool manifest-wrapper \$arch mt.exe -nologo -manifest \$manifests -out:\$out.manifest"
+ description = "LINK \$out"
+ rspfile = "\$out.rsp"
+ rspfile_content = "\$in_newline \$libs \$ldflags"
+ }
+ tool("stamp") {
+ command = "$python_path gyp-win-tool stamp \$out"
+ description = "STAMP \$out"
+ }
+ tool("copy") {
+ command = "$python_path gyp-win-tool recursive-mirror \$in \$out"
+ description = "COPY \$in \$out"
+ }
+}
+
+# 64-bit toolchain -------------------------------------------------------------
+
+toolchain("64") {
+}
+
+# SDK setup --------------------------------------------------------------------
+
+config("sdk") {
+ # The include path is the stuff returned by the script plus out own WTL
+ # checkout.
+ # TODO(brettw) should adding WTL be at this level or should it be more on
+ # a per-project basis?
+ includes = msvc_config[0] + "../../third_party/wtl/include"
+
+ defines = [
+ "_ATL_NO_OPENGL",
+ "_SECURE_ATL",
+ "_WIN32_WINNT=0x0602",
+ "_WINDOWS",
+ "CERT_CHAIN_PARA_HAS_EXTRA_FIELDS",
+ "NOMINMAX",
+ "NTDDI_VERSION=0x06020000",
+ "PSAPI_VERSION=1",
+ "WIN32",
+ "WIN32_LEAN_AND_MEAN",
+ "WINVER=0x0602",
+ ]
+}
diff --git a/tools/gn/secondary/build/config/win/get_msvc_config.py b/tools/gn/secondary/build/config/win/get_msvc_config.py
new file mode 100644
index 0000000..01380cd
--- /dev/null
+++ b/tools/gn/secondary/build/config/win/get_msvc_config.py
@@ -0,0 +1,77 @@
+# 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.
+
+# This file returns the MSVC config used by the Windows build.
+# It's a bit hardcoded right now. I suspect we want to build this functionality
+# into GN itself in the future.
+
+import sys
+
+# This script expects one parameter: the path to the root output directory.
+
+# TODO(brettw): do escaping.
+def FormatStringForGN(x):
+ return '"' + x + '"'
+
+def PrintListOfStrings(x):
+ print '['
+ for i in x:
+ print FormatStringForGN(i) + ', '
+ print ']'
+
+# GN wants system-absolutepaths to begin in slashes.
+sdk_root = '/C:\\Program Files (x86)\\Windows Kits\\8.0\\'
+vs_root = '/C:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\'
+
+def GetIncludes():
+ return [
+ sdk_root + 'Include\\shared',
+ sdk_root + 'Include\\um',
+ sdk_root + 'Include\\winrt',
+ vs_root + 'VC\\atlmfc\\include'
+ ]
+
+def _FormatAsEnvironmentBlock(envvar_dict):
+ """Format as an 'environment block' directly suitable for CreateProcess.
+ Briefly this is a list of key=value\0, terminated by an additional \0. See
+ CreateProcess documentation for more details."""
+ block = ''
+ nul = '\0'
+ for key, value in envvar_dict.iteritems():
+ block += key + '=' + value + nul
+ block += nul
+ return block
+
+def WriteEnvFile(file_path, values):
+ f = open(file_path, "w")
+ f.write(_FormatAsEnvironmentBlock(values))
+
+includes = GetIncludes()
+
+# Write the environment files.
+WriteEnvFile(sys.argv[1] + '\\environment.x86',
+ { 'TMP': 'C:\\Users\\brettw\\AppData\\Local\\Temp',
+ 'SYSTEMROOT': 'C:\\Windows',
+ 'TEMP': 'C:\\Users\\brettw\\AppData\\Local\\Temp',
+ 'LIB': 'c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\LIB;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\ATLMFC\\LIB;C:\\Program Files (x86)\\Microsoft SDKs\\Windows\\v7.0A\\lib;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\LIB;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\ATLMFC\\LIB;C:\\Program Files (x86)\\Microsoft SDKs\\Windows\\v7.0A\\lib;',
+ 'LIBPATH': 'C:\\Windows\\Microsoft.NET\\Framework\\v4.0.30319;C:\\Windows\\Microsoft.NET\\Framework\\v3.5;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\LIB;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\ATLMFC\\LIB;C:\\Windows\\Microsoft.NET\\Framework\\v4.0.30319;C:\\Windows\\Microsoft.NET\\Framework\\v3.5;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\LIB;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\ATLMFC\\LIB;',
+ 'PATH': 'C:\\apps\\depot_tools\\python_bin;c:\\Program Files (x86)\\Microsoft F#\\v4.0\\;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VSTSDB\\Deploy;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\Common7\\IDE\\;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\BIN;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\Common7\\Tools;C:\\Windows\\Microsoft.NET\\Framework\\v4.0.30319;C:\\Windows\\Microsoft.NET\\Framework\\v3.5;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\VCPackages;C:\\Program Files (x86)\\HTML Help Workshop;C:\\Program Files (x86)\\HTML Help Workshop;C:\\Program Files (x86)\\Microsoft SDKs\\Windows\\v7.0A\\bin\\NETFX 4.0 Tools;C:\\Program Files (x86)\\Microsoft SDKs\\Windows\\v7.0A\\bin;C:\\apps\\depot_tools\\python_bin;C:\\apps\\depot_tools\\;C:\\apps\\depot_tools\\;C:\\apps\\depot_tools\\;c:\\Program Files (x86)\\Microsoft F#\\v4.0\\;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VSTSDB\\Deploy;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\Common7\\IDE\\;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\BIN;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\Common7\\Tools;C:\\Windows\\Microsoft.NET\\Framework\\v4.0.30319;C:\\Windows\\Microsoft.NET\\Framework\\v3.5;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\VCPackages;C:\\Program Files (x86)\\HTML Help Workshop;C:\\Program Files (x86)\\Microsoft SDKs\\Windows\\v7.0A\\bin\\NETFX 4.0 Tools;C:\\Program Files (x86)\\Microsoft SDKs\\Windows\\v7.0A\\bin;C:\\Windows\\system32;C:\\Windows;C:\\Windows\\System32\\Wbem;C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\;C:\\windows\\corpam;C:\\python_26_amd64\\files;C:\\Windows\\ccmsetup;c:\\Program Files (x86)\\Microsoft SQL Server\\100\\Tools\\Binn\\;c:\\Program Files\\Microsoft SQL Server\\100\\Tools\\Binn\\;c:\\Program Files\\Microsoft SQL Server\\100\\DTS\\Binn\\;c:\\cygwin\\bin;C:\\apps\\;C:\\apps\\depot_tools;C:\\Program Files (x86)\\Windows Kits\\8.0\\Windows Performance Toolkit\\;C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\;C:\\Program Files (x86)\\Google\\Cert Installer;C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\;C:\\Program Files (x86)\\Google\\google_appengine\\',
+ 'PATHEXT': '=.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC',
+ 'INCLUDE': 'c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\INCLUDE;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\ATLMFC\\INCLUDE;C:\\Program Files (x86)\\Microsoft SDKs\\Windows\\v7.0A\\include;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\INCLUDE;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\ATLMFC\\INCLUDE;C:\\Program Files (x86)\\Microsoft SDKs\\Windows\\v7.0A\\include;'})
+
+WriteEnvFile(sys.argv[1] + '\\environment.x64',
+ { 'TMP': 'C:\\Users\\brettw\\AppData\\Local\\Temp',
+ 'SYSTEMROOT': 'C:\\Windows',
+ 'TEMP': 'C:\\Users\\brettw\\AppData\\Local\\Temp',
+ 'LIB': 'c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\LIB\\amd64;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\ATLMFC\\LIB\\amd64;C:\\Program Files (x86)\\Microsoft SDKs\\Windows\\v7.0A\\lib\\x64;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\LIB;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\ATLMFC\\LIB;C:\\Program Files (x86)\\Microsoft SDKs\\Windows\\v7.0A\\lib;',
+ 'LIBPATH': 'C:\\Windows\\Microsoft.NET\\Framework64\\v4.0.30319;C:\\Windows\\Microsoft.NET\\Framework64\\v3.5;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\LIB\\amd64;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\ATLMFC\\LIB\\amd64;C:\\Windows\\Microsoft.NET\\Framework\\v4.0.30319;C:\\Windows\\Microsoft.NET\\Framework\\v3.5;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\LIB;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\ATLMFC\\LIB;',
+ 'PATH': 'C:\\apps\\depot_tools\\python_bin;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\BIN\\amd64;C:\\Windows\\Microsoft.NET\\Framework64\\v4.0.30319;C:\\Windows\\Microsoft.NET\\Framework64\\v3.5;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\VCPackages;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\Common7\\IDE;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\Common7\\Tools;C:\\Program Files (x86)\\HTML Help Workshop;C:\\Program Files (x86)\\HTML Help Workshop;C:\\Program Files (x86)\\Microsoft SDKs\\Windows\\v7.0A\\bin\\NETFX 4.0 Tools\\x64;C:\\Program Files (x86)\\Microsoft SDKs\\Windows\\v7.0A\\bin\\x64;C:\\Program Files (x86)\\Microsoft SDKs\\Windows\\v7.0A\\bin;C:\\apps\\depot_tools\\python_bin;C:\\apps\\depot_tools\\;C:\\apps\\depot_tools\\;C:\\apps\\depot_tools\\;c:\\Program Files (x86)\\Microsoft F#\\v4.0\\;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VSTSDB\\Deploy;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\Common7\\IDE\\;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\BIN;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\Common7\\Tools;C:\\Windows\\Microsoft.NET\\Framework\\v4.0.30319;C:\\Windows\\Microsoft.NET\\Framework\\v3.5;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\VCPackages;C:\\Program Files (x86)\\HTML Help Workshop;C:\\Program Files (x86)\\Microsoft SDKs\\Windows\\v7.0A\\bin\\NETFX 4.0 Tools;C:\\Program Files (x86)\\Microsoft SDKs\\Windows\\v7.0A\\bin;C:\\Windows\\system32;C:\\Windows;C:\\Windows\\System32\\Wbem;C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\;C:\\windows\\corpam;C:\\python_26_amd64\\files;C:\\Windows\\ccmsetup;c:\\Program Files (x86)\\Microsoft SQL Server\\100\\Tools\\Binn\\;c:\\Program Files\\Microsoft SQL Server\\100\\Tools\\Binn\\;c:\\Program Files\\Microsoft SQL Server\\100\\DTS\\Binn\\;c:\\cygwin\\bin;C:\\apps\\;C:\\apps\\depot_tools;C:\\Program Files (x86)\\Windows Kits\\8.0\\Windows Performance Toolkit\\;C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\;C:\\Program Files (x86)\\Google\\Cert Installer;C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\;C:\\Program Files (x86)\\Google\\google_appengine\\',
+ 'PATHEXT': '.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC',
+ 'INCLUDE': 'c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\INCLUDE;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\ATLMFC\\INCLUDE;C:\\Program Files (x86)\\Microsoft SDKs\\Windows\\v7.0A\\include;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\INCLUDE;c:\\Program Files (x86)\\Microsoft Visual Studio 10.0\\VC\\ATLMFC\\INCLUDE;C:\\Program Files (x86)\\Microsoft SDKs\\Windows\\v7.0A\\include;'})
+
+# Return the includes and such.
+print '['
+PrintListOfStrings(includes)
+print ']'
+
diff --git a/tools/gn/secondary/build/config/win/get_msvc_config_real.py b/tools/gn/secondary/build/config/win/get_msvc_config_real.py
new file mode 100644
index 0000000..a209d7f
--- /dev/null
+++ b/tools/gn/secondary/build/config/win/get_msvc_config_real.py
@@ -0,0 +1,575 @@
+# 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.
+
+# This file copies the logic from GYP to find the MSVC configuration. It's not
+# currently used because it is too slow. We will probably build this
+# functionality into the C++ code in the future.
+
+"""Handle version information related to Visual Stuio."""
+
+import errno
+import os
+import re
+import subprocess
+import sys
+
+class VisualStudioVersion(object):
+ """Information regarding a version of Visual Studio."""
+
+ def __init__(self, short_name, description,
+ solution_version, project_version, flat_sln, uses_vcxproj,
+ path, sdk_based, default_toolset=None):
+ self.short_name = short_name
+ self.description = description
+ self.solution_version = solution_version
+ self.project_version = project_version
+ self.flat_sln = flat_sln
+ self.uses_vcxproj = uses_vcxproj
+ self.path = path
+ self.sdk_based = sdk_based
+ self.default_toolset = default_toolset
+
+ def ShortName(self):
+ return self.short_name
+
+ def Description(self):
+ """Get the full description of the version."""
+ return self.description
+
+ def SolutionVersion(self):
+ """Get the version number of the sln files."""
+ return self.solution_version
+
+ def ProjectVersion(self):
+ """Get the version number of the vcproj or vcxproj files."""
+ return self.project_version
+
+ def FlatSolution(self):
+ return self.flat_sln
+
+ def UsesVcxproj(self):
+ """Returns true if this version uses a vcxproj file."""
+ return self.uses_vcxproj
+
+ def ProjectExtension(self):
+ """Returns the file extension for the project."""
+ return self.uses_vcxproj and '.vcxproj' or '.vcproj'
+
+ def Path(self):
+ """Returns the path to Visual Studio installation."""
+ return self.path
+
+ def ToolPath(self, tool):
+ """Returns the path to a given compiler tool. """
+ return os.path.normpath(os.path.join(self.path, "VC/bin", tool))
+
+ def DefaultToolset(self):
+ """Returns the msbuild toolset version that will be used in the absence
+ of a user override."""
+ return self.default_toolset
+
+ def SetupScript(self, target_arch):
+ """Returns a command (with arguments) to be used to set up the
+ environment."""
+ # Check if we are running in the SDK command line environment and use
+ # the setup script from the SDK if so. |target_arch| should be either
+ # 'x86' or 'x64'.
+ assert target_arch in ('x86', 'x64')
+ sdk_dir = os.environ.get('WindowsSDKDir')
+ if self.sdk_based and sdk_dir:
+ return [os.path.normpath(os.path.join(sdk_dir, 'Bin/SetEnv.Cmd')),
+ '/' + target_arch]
+ else:
+ # We don't use VC/vcvarsall.bat for x86 because vcvarsall calls
+ # vcvars32, which it can only find if VS??COMNTOOLS is set, which it
+ # isn't always.
+ if target_arch == 'x86':
+ return [os.path.normpath(
+ os.path.join(self.path, 'Common7/Tools/vsvars32.bat'))]
+ else:
+ assert target_arch == 'x64'
+ arg = 'x86_amd64'
+ if (os.environ.get('PROCESSOR_ARCHITECTURE') == 'AMD64' or
+ os.environ.get('PROCESSOR_ARCHITEW6432') == 'AMD64'):
+ # Use the 64-on-64 compiler if we can.
+ arg = 'amd64'
+ return [os.path.normpath(
+ os.path.join(self.path, 'VC/vcvarsall.bat')), arg]
+
+
+def _RegistryQueryBase(sysdir, key, value):
+ """Use reg.exe to read a particular key.
+
+ While ideally we might use the win32 module, we would like gyp to be
+ python neutral, so for instance cygwin python lacks this module.
+
+ Arguments:
+ sysdir: The system subdirectory to attempt to launch reg.exe from.
+ key: The registry key to read from.
+ value: The particular value to read.
+ Return:
+ stdout from reg.exe, or None for failure.
+ """
+ # Skip if not on Windows or Python Win32 setup issue
+ if sys.platform not in ('win32', 'cygwin'):
+ return None
+ # Setup params to pass to and attempt to launch reg.exe
+ cmd = [os.path.join(os.environ.get('WINDIR', ''), sysdir, 'reg.exe'),
+ 'query', key]
+ if value:
+ cmd.extend(['/v', value])
+ p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+ # Obtain the stdout from reg.exe, reading to the end so p.returncode is valid
+ # Note that the error text may be in [1] in some cases
+ text = p.communicate()[0]
+ # Check return code from reg.exe; officially 0==success and 1==error
+ if p.returncode:
+ return None
+ return text
+
+
+def _RegistryQuery(key, value=None):
+ """Use reg.exe to read a particular key through _RegistryQueryBase.
+
+ First tries to launch from %WinDir%\Sysnative to avoid WoW64 redirection. If
+ that fails, it falls back to System32. Sysnative is available on Vista and
+ up and available on Windows Server 2003 and XP through KB patch 942589. Note
+ that Sysnative will always fail if using 64-bit python due to it being a
+ virtual directory and System32 will work correctly in the first place.
+
+ KB 942589 - http://support.microsoft.com/kb/942589/en-us.
+
+ Arguments:
+ key: The registry key.
+ value: The particular registry value to read (optional).
+ Return:
+ stdout from reg.exe, or None for failure.
+ """
+ text = None
+ try:
+ text = _RegistryQueryBase('Sysnative', key, value)
+ except OSError, e:
+ if e.errno == errno.ENOENT:
+ text = _RegistryQueryBase('System32', key, value)
+ else:
+ raise
+ return text
+
+
+def _RegistryGetValue(key, value):
+ """Use reg.exe to obtain the value of a registry key.
+
+ Args:
+ key: The registry key.
+ value: The particular registry value to read.
+ Return:
+ contents of the registry key's value, or None on failure.
+ """
+ text = _RegistryQuery(key, value)
+ if not text:
+ return None
+ # Extract value.
+ match = re.search(r'REG_\w+\s+([^\r]+)\r\n', text)
+ if not match:
+ return None
+ return match.group(1)
+
+
+def _RegistryKeyExists(key):
+ """Use reg.exe to see if a key exists.
+
+ Args:
+ key: The registry key to check.
+ Return:
+ True if the key exists
+ """
+ if not _RegistryQuery(key):
+ return False
+ return True
+
+
+def _CreateVersion(name, path, sdk_based=False):
+ """Sets up MSVS project generation.
+
+ Setup is based off the GYP_MSVS_VERSION environment variable or whatever is
+ autodetected if GYP_MSVS_VERSION is not explicitly specified. If a version is
+ passed in that doesn't match a value in versions python will throw a error.
+ """
+ if path:
+ path = os.path.normpath(path)
+ versions = {
+ '2013': VisualStudioVersion('2013',
+ 'Visual Studio 2013',
+ solution_version='13.00',
+ project_version='4.0',
+ flat_sln=False,
+ uses_vcxproj=True,
+ path=path,
+ sdk_based=sdk_based,
+ default_toolset='v110'),
+ '2013e': VisualStudioVersion('2013e',
+ 'Visual Studio 2013',
+ solution_version='13.00',
+ project_version='4.0',
+ flat_sln=True,
+ uses_vcxproj=True,
+ path=path,
+ sdk_based=sdk_based,
+ default_toolset='v110'),
+ '2012': VisualStudioVersion('2012',
+ 'Visual Studio 2012',
+ solution_version='12.00',
+ project_version='4.0',
+ flat_sln=False,
+ uses_vcxproj=True,
+ path=path,
+ sdk_based=sdk_based,
+ default_toolset='v110'),
+ '2012e': VisualStudioVersion('2012e',
+ 'Visual Studio 2012',
+ solution_version='12.00',
+ project_version='4.0',
+ flat_sln=True,
+ uses_vcxproj=True,
+ path=path,
+ sdk_based=sdk_based,
+ default_toolset='v110'),
+ '2010': VisualStudioVersion('2010',
+ 'Visual Studio 2010',
+ solution_version='11.00',
+ project_version='4.0',
+ flat_sln=False,
+ uses_vcxproj=True,
+ path=path,
+ sdk_based=sdk_based),
+ '2010e': VisualStudioVersion('2010e',
+ 'Visual Studio 2010',
+ solution_version='11.00',
+ project_version='4.0',
+ flat_sln=True,
+ uses_vcxproj=True,
+ path=path,
+ sdk_based=sdk_based),
+ '2008': VisualStudioVersion('2008',
+ 'Visual Studio 2008',
+ solution_version='10.00',
+ project_version='9.00',
+ flat_sln=False,
+ uses_vcxproj=False,
+ path=path,
+ sdk_based=sdk_based),
+ '2008e': VisualStudioVersion('2008e',
+ 'Visual Studio 2008',
+ solution_version='10.00',
+ project_version='9.00',
+ flat_sln=True,
+ uses_vcxproj=False,
+ path=path,
+ sdk_based=sdk_based),
+ '2005': VisualStudioVersion('2005',
+ 'Visual Studio 2005',
+ solution_version='9.00',
+ project_version='8.00',
+ flat_sln=False,
+ uses_vcxproj=False,
+ path=path,
+ sdk_based=sdk_based),
+ '2005e': VisualStudioVersion('2005e',
+ 'Visual Studio 2005',
+ solution_version='9.00',
+ project_version='8.00',
+ flat_sln=True,
+ uses_vcxproj=False,
+ path=path,
+ sdk_based=sdk_based),
+ }
+ return versions[str(name)]
+
+
+def _ConvertToCygpath(path):
+ """Convert to cygwin path if we are using cygwin."""
+ if sys.platform == 'cygwin':
+ p = subprocess.Popen(['cygpath', path], stdout=subprocess.PIPE)
+ path = p.communicate()[0].strip()
+ return path
+
+
+def _DetectVisualStudioVersions(versions_to_check, force_express):
+ """Collect the list of installed visual studio versions.
+
+ Returns:
+ A list of visual studio versions installed in descending order of
+ usage preference.
+ Base this on the registry and a quick check if devenv.exe exists.
+ Only versions 8-10 are considered.
+ Possibilities are:
+ 2005(e) - Visual Studio 2005 (8)
+ 2008(e) - Visual Studio 2008 (9)
+ 2010(e) - Visual Studio 2010 (10)
+ 2012(e) - Visual Studio 2012 (11)
+ 2013(e) - Visual Studio 2013 (11)
+ Where (e) is e for express editions of MSVS and blank otherwise.
+ """
+ version_to_year = {
+ '8.0': '2005',
+ '9.0': '2008',
+ '10.0': '2010',
+ '11.0': '2012',
+ '12.0': '2013',
+ }
+ versions = []
+ for version in versions_to_check:
+ # Old method of searching for which VS version is installed
+ # We don't use the 2010-encouraged-way because we also want to get the
+ # path to the binaries, which it doesn't offer.
+ keys = [r'HKLM\Software\Microsoft\VisualStudio\%s' % version,
+ r'HKLM\Software\Wow6432Node\Microsoft\VisualStudio\%s' % version,
+ r'HKLM\Software\Microsoft\VCExpress\%s' % version,
+ r'HKLM\Software\Wow6432Node\Microsoft\VCExpress\%s' % version]
+ for index in range(len(keys)):
+ path = _RegistryGetValue(keys[index], 'InstallDir')
+ if not path:
+ continue
+ path = _ConvertToCygpath(path)
+ # Check for full.
+ full_path = os.path.join(path, 'devenv.exe')
+ express_path = os.path.join(path, 'vcexpress.exe')
+ if not force_express and os.path.exists(full_path):
+ # Add this one.
+ versions.append(_CreateVersion(version_to_year[version],
+ os.path.join(path, '..', '..')))
+ # Check for express.
+ elif os.path.exists(express_path):
+ # Add this one.
+ versions.append(_CreateVersion(version_to_year[version] + 'e',
+ os.path.join(path, '..', '..')))
+
+ # The old method above does not work when only SDK is installed.
+ keys = [r'HKLM\Software\Microsoft\VisualStudio\SxS\VC7',
+ r'HKLM\Software\Wow6432Node\Microsoft\VisualStudio\SxS\VC7']
+ for index in range(len(keys)):
+ path = _RegistryGetValue(keys[index], version)
+ if not path:
+ continue
+ path = _ConvertToCygpath(path)
+ versions.append(_CreateVersion(version_to_year[version] + 'e',
+ os.path.join(path, '..'), sdk_based=True))
+
+ return versions
+
+
+def SelectVisualStudioVersion(version='auto'):
+ """Select which version of Visual Studio projects to generate.
+
+ Arguments:
+ version: Hook to allow caller to force a particular version (vs auto).
+ Returns:
+ An object representing a visual studio project format version.
+ """
+ # In auto mode, check environment variable for override.
+ if version == 'auto':
+ version = os.environ.get('GYP_MSVS_VERSION', 'auto')
+ version_map = {
+ 'auto': ('10.0', '9.0', '8.0', '11.0'),
+ '2005': ('8.0',),
+ '2005e': ('8.0',),
+ '2008': ('9.0',),
+ '2008e': ('9.0',),
+ '2010': ('10.0',),
+ '2010e': ('10.0',),
+ '2012': ('11.0',),
+ '2012e': ('11.0',),
+ '2013': ('12.0',),
+ '2013e': ('12.0',),
+ }
+ override_path = os.environ.get('GYP_MSVS_OVERRIDE_PATH')
+ if override_path:
+ msvs_version = os.environ.get('GYP_MSVS_VERSION')
+ if not msvs_version or 'e' not in msvs_version:
+ raise ValueError('GYP_MSVS_OVERRIDE_PATH requires GYP_MSVS_VERSION to be '
+ 'set to an "e" version (e.g. 2010e)')
+ return _CreateVersion(msvs_version, override_path, sdk_based=True)
+ version = str(version)
+ versions = _DetectVisualStudioVersions(version_map[version], 'e' in version)
+ if not versions:
+ if version == 'auto':
+ # Default to 2005 if we couldn't find anything
+ return _CreateVersion('2005', None)
+ else:
+ return _CreateVersion(version, None)
+ return versions[0]
+
+def GenerateEnvironmentFiles(toplevel_build_dir, generator_flags, open_out):
+ """It's not sufficient to have the absolute path to the compiler, linker,
+ etc. on Windows, as those tools rely on .dlls being in the PATH. We also
+ need to support both x86 and x64 compilers within the same build (to support
+ msvs_target_platform hackery). Different architectures require a different
+ compiler binary, and different supporting environment variables (INCLUDE,
+ LIB, LIBPATH). So, we extract the environment here, wrap all invocations
+ of compiler tools (cl, link, lib, rc, midl, etc.) via win_tool.py which
+ sets up the environment, and then we do not prefix the compiler with
+ an absolute path, instead preferring something like "cl.exe" in the rule
+ which will then run whichever the environment setup has put in the path.
+ When the following procedure to generate environment files does not
+ meet your requirement (e.g. for custom toolchains), you can pass
+ "-G ninja_use_custom_environment_files" to the gyp to suppress file
+ generation and use custom environment files prepared by yourself."""
+ archs = ('x86', 'x64')
+ if generator_flags.get('ninja_use_custom_environment_files', 0):
+ cl_paths = {}
+ for arch in archs:
+ cl_paths[arch] = 'cl.exe'
+ return cl_paths
+ vs = GetVSVersion(generator_flags)
+ cl_paths = {}
+ for arch in archs:
+ # Extract environment variables for subprocesses.
+ args = vs.SetupScript(arch)
+ args.extend(('&&', 'set'))
+ popen = subprocess.Popen(
+ args, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+ variables, _ = popen.communicate()
+ env = _ExtractImportantEnvironment(variables)
+ env_block = _FormatAsEnvironmentBlock(env)
+ f = open_out(os.path.join(toplevel_build_dir, 'environment.' + arch), 'wb')
+ f.write(env_block)
+ f.close()
+
+ # Find cl.exe location for this architecture.
+ args = vs.SetupScript(arch)
+ args.extend(('&&',
+ 'for', '%i', 'in', '(cl.exe)', 'do', '@echo', 'LOC:%~$PATH:i'))
+ popen = subprocess.Popen(args, shell=True, stdout=subprocess.PIPE)
+ output, _ = popen.communicate()
+ cl_paths[arch] = _ExtractCLPath(output)
+ return cl_paths
+
+def OpenOutput(path, mode='w'):
+ """Open |path| for writing, creating directories if necessary."""
+ try:
+ os.makedirs(os.path.dirname(path))
+ except OSError:
+ pass
+ return open(path, mode)
+
+vs_version = None
+def GetVSVersion(generator_flags):
+ global vs_version
+ if not vs_version:
+ vs_version = SelectVisualStudioVersion(
+ generator_flags.get('msvs_version', 'auto'))
+ return vs_version
+
+def _ExtractImportantEnvironment(output_of_set):
+ """Extracts environment variables required for the toolchain to run from
+ a textual dump output by the cmd.exe 'set' command."""
+ envvars_to_save = (
+ 'goma_.*', # TODO(scottmg): This is ugly, but needed for goma.
+ 'include',
+ 'lib',
+ 'libpath',
+ 'path',
+ 'pathext',
+ 'systemroot',
+ 'temp',
+ 'tmp',
+ )
+ env = {}
+ for line in output_of_set.splitlines():
+ for envvar in envvars_to_save:
+ if re.match(envvar + '=', line.lower()):
+ var, setting = line.split('=', 1)
+ if envvar == 'path':
+ # Our own rules (for running gyp-win-tool) and other actions in
+ # Chromium rely on python being in the path. Add the path to this
+ # python here so that if it's not in the path when ninja is run
+ # later, python will still be found.
+ setting = os.path.dirname(sys.executable) + os.pathsep + setting
+ env[var.upper()] = setting
+ break
+ for required in ('SYSTEMROOT', 'TEMP', 'TMP'):
+ if required not in env:
+ raise Exception('Environment variable "%s" '
+ 'required to be set to valid path' % required)
+ return env
+
+def _FormatAsEnvironmentBlock(envvar_dict):
+ """Format as an 'environment block' directly suitable for CreateProcess.
+ Briefly this is a list of key=value\0, terminated by an additional \0. See
+ CreateProcess documentation for more details."""
+ block = ''
+ nul = '\0'
+ for key, value in envvar_dict.iteritems():
+ block += key + '=' + value + nul
+ block += nul
+ return block
+
+
+def GenerateEnvironmentFiles(toplevel_build_dir, generator_flags):
+ """It's not sufficient to have the absolute path to the compiler, linker,
+ etc. on Windows, as those tools rely on .dlls being in the PATH. We also
+ need to support both x86 and x64 compilers within the same build (to support
+ msvs_target_platform hackery). Different architectures require a different
+ compiler binary, and different supporting environment variables (INCLUDE,
+ LIB, LIBPATH). So, we extract the environment here, wrap all invocations
+ of compiler tools (cl, link, lib, rc, midl, etc.) via win_tool.py which
+ sets up the environment, and then we do not prefix the compiler with
+ an absolute path, instead preferring something like "cl.exe" in the rule
+ which will then run whichever the environment setup has put in the path.
+ When the following procedure to generate environment files does not
+ meet your requirement (e.g. for custom toolchains), you can pass
+ "-G ninja_use_custom_environment_files" to the gyp to suppress file
+ generation and use custom environment files prepared by yourself."""
+ archs = ('x86', 'x64')
+ if generator_flags.get('ninja_use_custom_environment_files', 0):
+ cl_paths = {}
+ for arch in archs:
+ cl_paths[arch] = 'cl.exe'
+ return cl_paths
+ vs = GetVSVersion(generator_flags)
+ cl_paths = {}
+ for arch in archs:
+ # Extract environment variables for subprocesses.
+ args = vs.SetupScript(arch)
+ args.extend(('&&', 'set'))
+ popen = subprocess.Popen(
+ args, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+ variables, _ = popen.communicate()
+ env = _ExtractImportantEnvironment(variables)
+ env_block = _FormatAsEnvironmentBlock(env)
+ f = OpenOutput(os.path.join(toplevel_build_dir, 'environment.' + arch), 'wb')
+ f.write(env_block)
+ f.close()
+
+ # Find cl.exe location for this architecture.
+ args = vs.SetupScript(arch)
+ args.extend(('&&',
+ 'for', '%i', 'in', '(cl.exe)', 'do', '@echo', 'LOC:%~$PATH:i'))
+ popen = subprocess.Popen(args, shell=True, stdout=subprocess.PIPE)
+ output, _ = popen.communicate()
+ cl_paths[arch] = _ExtractCLPath(output)
+ return cl_paths
+
+def _ExtractCLPath(output_of_where):
+ """Gets the path to cl.exe based on the output of calling the environment
+ setup batch file, followed by the equivalent of `where`."""
+ # Take the first line, as that's the first found in the PATH.
+ for line in output_of_where.strip().splitlines():
+ if line.startswith('LOC:'):
+ return line[len('LOC:'):].strip()
+
+#print SelectVisualStudioVersion().DefaultToolset()
+#GenerateEnvironmentFiles("D:\\src\\src1\\src\\out\\gn\\eraseme", {})
+#print '"', GetVSVersion({}).Path(), '"'
+print '"', GetVSVersion({}).sdk_based, '"'
+
+#-------------------------------------------------------------------------------
+
+version_info = {
+ '2010': {
+ 'includes': [
+ 'VC\\atlmfc\\include',
+ ],
+ },
+}
diff --git a/tools/gn/secondary/ipc/BUILD.gn b/tools/gn/secondary/ipc/BUILD.gn
new file mode 100644
index 0000000..5e55ee9
--- /dev/null
+++ b/tools/gn/secondary/ipc/BUILD.gn
@@ -0,0 +1,168 @@
+# Copyright (c) 2012 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.
+
+component("ipc") {
+ sources = [
+ "file_descriptor_set_posix.cc",
+ "file_descriptor_set_posix.h",
+ "ipc_channel.cc",
+ "ipc_channel.h",
+ "ipc_channel_factory.cc",
+ "ipc_channel_factory.h",
+ "ipc_channel_handle.h",
+ "ipc_channel_nacl.cc",
+ "ipc_channel_nacl.h",
+ "ipc_channel_posix.cc",
+ "ipc_channel_posix.h",
+ "ipc_channel_proxy.cc",
+ "ipc_channel_proxy.h",
+ "ipc_channel_reader.cc",
+ "ipc_channel_reader.h",
+ "ipc_channel_win.cc",
+ "ipc_channel_win.h",
+ "ipc_descriptors.h",
+ "ipc_export.h",
+ "ipc_forwarding_message_filter.cc",
+ "ipc_forwarding_message_filter.h",
+ "ipc_listener.h",
+ "ipc_logging.cc",
+ "ipc_logging.h",
+ "ipc_message.cc",
+ "ipc_message.h",
+ "ipc_message_macros.h",
+ "ipc_message_start.h",
+ "ipc_message_utils.cc",
+ "ipc_message_utils.h",
+ "ipc_param_traits.h",
+ "ipc_platform_file.cc",
+ "ipc_platform_file.h",
+ "ipc_sender.h",
+ "ipc_switches.cc",
+ "ipc_switches.h",
+ "ipc_sync_channel.cc",
+ "ipc_sync_channel.h",
+ "ipc_sync_message.cc",
+ "ipc_sync_message.h",
+ "ipc_sync_message_filter.cc",
+ "ipc_sync_message_filter.h",
+ "param_traits_log_macros.h",
+ "param_traits_macros.h",
+ "param_traits_read_macros.h",
+ "param_traits_write_macros.h",
+ "struct_constructor_macros.h",
+ "struct_destructor_macros.h",
+ "unix_domain_socket_util.cc",
+ "unix_domain_socket_util.h",
+ ]
+
+ #if (!is_untrusted_nacl) {
+ sources -= [
+ "ipc_channel_nacl.cc",
+ "ipc_channel_nacl.h",
+ ]
+
+ if (is_win || is_ios) {
+ sources -= [
+ "ipc_channel_factory.cc",
+ "unix_domain_socket_util.cc",
+ ]
+ }
+
+ defines = [ "IPC_IMPLEMENTATION" ]
+
+ deps = [
+ "//base",
+ # TODO(viettrungluu): Needed for base/lazy_instance.h, which is suspect.
+ "//base/third_party/dynamic_annotations",
+ ]
+}
+
+test("ipc_tests") {
+ sources = [
+ "file_descriptor_set_posix_unittest.cc",
+ "ipc_channel_posix_unittest.cc",
+ "ipc_channel_unittest.cc",
+ "ipc_fuzzing_tests.cc",
+ "ipc_message_unittest.cc",
+ "ipc_message_utils_unittest.cc",
+ "ipc_send_fds_test.cc",
+ "ipc_sync_channel_unittest.cc",
+ "ipc_sync_message_unittest.cc",
+ "ipc_sync_message_unittest.h",
+ "ipc_test_base.cc",
+ "ipc_test_base.h",
+ "sync_socket_unittest.cc",
+ "unix_domain_socket_util_unittest.cc",
+ ]
+
+ #if (toolkit_uses_gtk) {
+ # deps += "/build/linux/system:gtk"
+ #}
+ if (is_win || is_ios) {
+ sources -= "unix_domain_socket_util_unittest.cc"
+ }
+ #if (is_android && gtest_target_type == "shared_library") {
+ # deps += "/testing/android/native_test.gyp:native_testNative_code"
+ #}
+ #if (is_posix && !is_mac && !is_android) {
+ # if (linux_use_tcmalloc) {
+ # deps += "/base/allocator"
+ # }
+ #}
+
+ deps = [
+ ":ipc",
+ ":test_support_ipc",
+ "//base",
+ "//base:base_i18n",
+ "//base:run_all_unittests",
+ "//base:test_support_base",
+ "//testing:gtest",
+ ]
+}
+
+test("ipc_perftests") {
+ sources = [
+ "ipc_perftests.cc",
+ "ipc_test_base.cc",
+ "ipc_test_base.h",
+ ]
+
+ #if (toolkit_uses_gtk) {
+ # deps += "/build/linux/system:gtk"
+ #}
+ #if (is_android && gtest_target_type == "shared_library") {
+ # deps += "/testing/android/native_test.gyp:native_testNative_code"
+ #}
+ #if (is_posix && !is_mac && !is_android) {
+ # if (linux_use_tcmalloc) {
+ # deps += "/base/allocator"
+ # }
+ #}
+
+ deps = [
+ ":ipc",
+ ":test_support_ipc",
+ "//base",
+ "//base:base_i18n",
+ "//base:test_support_base",
+ "//base:test_support_perf",
+ "//testing:gtest",
+ ]
+}
+
+static_library("test_support_ipc") {
+ sources = [
+ "ipc_multiprocess_test.cc",
+ "ipc_multiprocess_test.h",
+ "ipc_test_sink.cc",
+ "ipc_test_sink.h",
+ ]
+ deps = [
+ ":ipc",
+ "//base",
+ "//testing:gtest",
+ ]
+}
+
diff --git a/tools/gn/secondary/testing/BUILD.gn b/tools/gn/secondary/testing/BUILD.gn
new file mode 100644
index 0000000..b54ceba
--- /dev/null
+++ b/tools/gn/secondary/testing/BUILD.gn
@@ -0,0 +1,44 @@
+# 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.
+
+static_library("gtest") {
+ sources = [
+ "gtest/include/gtest/gtest-death-test.h",
+ "gtest/include/gtest/gtest-message.h",
+ "gtest/include/gtest/gtest-param-test.h",
+ "gtest/include/gtest/gtest-printers.h",
+ "gtest/include/gtest/gtest-spi.h",
+ "gtest/include/gtest/gtest-test-part.h",
+ "gtest/include/gtest/gtest-typed-test.h",
+ "gtest/include/gtest/gtest.h",
+ "gtest/include/gtest/gtest_pred_impl.h",
+ "gtest/include/gtest/internal/gtest-death-test-internal.h",
+ "gtest/include/gtest/internal/gtest-filepath.h",
+ "gtest/include/gtest/internal/gtest-internal.h",
+ "gtest/include/gtest/internal/gtest-linked_ptr.h",
+ "gtest/include/gtest/internal/gtest-param-util-generated.h",
+ "gtest/include/gtest/internal/gtest-param-util.h",
+ "gtest/include/gtest/internal/gtest-port.h",
+ "gtest/include/gtest/internal/gtest-string.h",
+ "gtest/include/gtest/internal/gtest-tuple.h",
+ "gtest/include/gtest/internal/gtest-type-util.h",
+ #"gtest/src/gtest-all.cc", # Not needed by our build.
+ "gtest/src/gtest-death-test.cc",
+ "gtest/src/gtest-filepath.cc",
+ "gtest/src/gtest-internal-inl.h",
+ "gtest/src/gtest-port.cc",
+ "gtest/src/gtest-printers.cc",
+ "gtest/src/gtest-test-part.cc",
+ "gtest/src/gtest-typed-test.cc",
+ "gtest/src/gtest.cc",
+ "multiprocess_func_list.cc",
+ "multiprocess_func_list.h",
+ "platform_test.h",
+ ]
+
+}
+
+static_library("gmock") {
+
+}
diff --git a/tools/gn/secondary/third_party/modp_b64/BUILD.gn b/tools/gn/secondary/third_party/modp_b64/BUILD.gn
new file mode 100644
index 0000000..5598f12
--- /dev/null
+++ b/tools/gn/secondary/third_party/modp_b64/BUILD.gn
@@ -0,0 +1,11 @@
+# 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.
+
+static_library("modp_b64") {
+ sources = [
+ "modp_b64.cc",
+ "modp_b64.h",
+ "modp_b64_data.h",
+ ]
+}
diff --git a/tools/gn/settings.cc b/tools/gn/settings.cc
new file mode 100644
index 0000000..82014a7
--- /dev/null
+++ b/tools/gn/settings.cc
@@ -0,0 +1,38 @@
+// 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/settings.h"
+
+#include "base/logging.h"
+#include "tools/gn/filesystem_utils.h"
+
+Settings::Settings(const BuildSettings* build_settings,
+ const Toolchain* toolchain,
+ const std::string& output_subdir_name)
+ : build_settings_(build_settings),
+ toolchain_(toolchain),
+ target_os_(WIN), // FIXME(brettw) set this properly.
+ import_manager_(),
+ base_config_(this) {
+ DCHECK(output_subdir_name.find('/') == std::string::npos);
+ if (output_subdir_name.empty()) {
+ toolchain_output_dir_ = build_settings->build_dir();
+ } else {
+ // We guarantee this ends in a slash.
+ toolchain_output_subdir_.value().append(output_subdir_name);
+ toolchain_output_subdir_.value().push_back('/');
+
+ toolchain_output_dir_ = SourceDir(build_settings->build_dir().value() +
+ toolchain_output_subdir_.value());
+ }
+ // The output dir will be null in some tests and when invoked to parsed
+ // one-off data without doing generation.
+ if (!toolchain_output_dir_.is_null())
+ toolchain_gen_dir_ = SourceDir(toolchain_output_dir_.value() + "gen/");
+}
+
+Settings::~Settings() {
+}
+
+
diff --git a/tools/gn/settings.h b/tools/gn/settings.h
new file mode 100644
index 0000000..93a1ae6
--- /dev/null
+++ b/tools/gn/settings.h
@@ -0,0 +1,107 @@
+// 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_SETTINGS_H_
+#define TOOLS_GN_SETTINGS_H_
+
+#include "base/files/file_path.h"
+#include "tools/gn/build_settings.h"
+#include "tools/gn/import_manager.h"
+#include "tools/gn/output_file.h"
+#include "tools/gn/scope.h"
+#include "tools/gn/source_dir.h"
+#include "tools/gn/toolchain.h"
+
+// Holds the settings for one toolchain invocation. There will be one
+// Settings object for each toolchain type, each referring to the same
+// BuildSettings object for shared stuff.
+//
+// The Settings object is const once it is constructed, which allows us to
+// use it from multiple threads during target generation without locking (which
+// is important, because it gets used a lot).
+//
+// The Toolchain object holds the set of stuff that is set by the toolchain
+// declaration, which obviously needs to be set later when we actually parse
+// the file with the toolchain declaration in it.
+class Settings {
+ public:
+ enum TargetOS {
+ UNKNOWN,
+ LINUX,
+ MAC,
+ WIN
+ };
+
+ // Constructs a toolchain settings. The output_subdir_name is the name we
+ // should use for the subdirectory in the build output directory for this
+ // toolchain's outputs. It should have no slashes in it. The default
+ // toolchain should use an empty string.
+ Settings(const BuildSettings* build_settings,
+ const Toolchain* toolchain,
+ const std::string& output_subdir_name);
+ ~Settings();
+
+ const BuildSettings* build_settings() const { return build_settings_; }
+
+ // Danger: this must only be used for getting the toolchain label until the
+ // toolchain has been resolved. Otherwise, it will be modified on an
+ // arbitrary thread when the toolchain invocation is found. Generally, you
+ // will only read this from the target generation where we know everything
+ // has been resolved and won't change.
+ const Toolchain* toolchain() const { return toolchain_; }
+
+ bool IsMac() const { return target_os_ == MAC; }
+ bool IsWin() const { return target_os_ == WIN; }
+
+ TargetOS target_os() const { return target_os_; }
+ void set_target_os(TargetOS t) { target_os_ = t; }
+
+ const OutputFile& toolchain_output_subdir() const {
+ return toolchain_output_subdir_;
+ }
+ const SourceDir& toolchain_output_dir() const {
+ return toolchain_output_dir_;
+ }
+
+ // Directory for generated files.
+ const SourceDir& toolchain_gen_dir() const {
+ return toolchain_gen_dir_;
+ }
+
+ // The import manager caches the result of executing imported files in the
+ // context of a given settings object.
+ //
+ // See the ItemTree getter in GlobalSettings for why this doesn't return a
+ // const pointer.
+ ImportManager& import_manager() const { return import_manager_; }
+
+ const Scope* base_config() const { return &base_config_; }
+ Scope* base_config() { return &base_config_; }
+
+ private:
+ const BuildSettings* build_settings_;
+
+ const Toolchain* toolchain_;
+
+ TargetOS target_os_;
+
+ mutable ImportManager import_manager_;
+
+ // The subdirectory inside the build output for this toolchain. For the
+ // default toolchain, this will be empty (since the deafult toolchain's
+ // output directory is the same as the build directory). When nonempty, this
+ // is guaranteed to end in a slash.
+ OutputFile toolchain_output_subdir_;
+
+ // Full source file path to the toolchain output directory.
+ SourceDir toolchain_output_dir_;
+
+ SourceDir toolchain_gen_dir_;
+
+ Scope base_config_;
+
+ DISALLOW_COPY_AND_ASSIGN(Settings);
+};
+
+#endif // TOOLS_GN_SETTINGS_H_
diff --git a/tools/gn/setup.cc b/tools/gn/setup.cc
new file mode 100644
index 0000000..f93cd4d
--- /dev/null
+++ b/tools/gn/setup.cc
@@ -0,0 +1,195 @@
+// 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/setup.h"
+
+#include "base/command_line.h"
+#include "base/file_util.h"
+#include "base/files/file_path.h"
+#include "tools/gn/filesystem_utils.h"
+#include "tools/gn/input_file.h"
+#include "tools/gn/parse_tree.h"
+#include "tools/gn/parser.h"
+#include "tools/gn/source_dir.h"
+#include "tools/gn/source_file.h"
+#include "tools/gn/tokenizer.h"
+#include "tools/gn/value.h"
+
+namespace {
+
+// More logging.
+const char kSwitchVerbose[] = "v";
+
+const char kSwitchRoot[] = "root";
+const char kSecondarySource[] = "secondary";
+
+const base::FilePath::CharType kGnFile[] = FILE_PATH_LITERAL(".gn");
+
+base::FilePath FindDotFile(const base::FilePath& current_dir) {
+ base::FilePath try_this_file = current_dir.Append(kGnFile);
+ if (base::PathExists(try_this_file))
+ return try_this_file;
+
+ base::FilePath with_no_slash = current_dir.StripTrailingSeparators();
+ base::FilePath up_one_dir = with_no_slash.DirName();
+ if (up_one_dir == current_dir)
+ return base::FilePath(); // Got to the top.
+
+ return FindDotFile(up_one_dir);
+}
+
+} // namespace
+
+Setup::Setup()
+ : dotfile_toolchain_(Label()),
+ dotfile_settings_(&dotfile_build_settings_, &dotfile_toolchain_,
+ std::string()),
+ dotfile_scope_(&dotfile_settings_) {
+}
+
+Setup::~Setup() {
+}
+
+bool Setup::DoSetup() {
+ CommandLine* cmdline = CommandLine::ForCurrentProcess();
+
+ scheduler_.set_verbose_logging(cmdline->HasSwitch(kSwitchVerbose));
+
+ if (!FillSourceDir(*cmdline))
+ return false;
+ if (!RunConfigFile())
+ return false;
+ if (!FillOtherConfig(*cmdline))
+ return false;
+
+ // FIXME(brettw) get python path!
+/*#if defined(OS_WIN)
+ build_settings_.set_python_path(base::FilePath(
+ //L"P:\\depot_tools\\python_bin\\python.exe"));
+ L"C:\\apps\\depot_tools\\python_bin\\python.exe"));
+#else*/
+ build_settings_.set_python_path(base::FilePath("python"));
+//#endif
+
+ build_settings_.SetBuildDir(SourceDir("//out/gn/"));
+
+ return true;
+}
+
+bool Setup::Run() {
+ // Load the root build file and start runnung.
+ build_settings_.toolchain_manager().StartLoadingUnlocked(
+ SourceFile("//BUILD.gn"));
+ if (!scheduler_.Run())
+ return false;
+
+ Err err = build_settings_.item_tree().CheckForBadItems();
+ if (err.has_error()) {
+ err.PrintToStdout();
+ return false;
+ }
+ return true;
+}
+
+bool Setup::FillSourceDir(const CommandLine& cmdline) {
+ // Find the .gn file.
+ base::FilePath root_path;
+
+ // Prefer the command line args to the config file.
+ base::FilePath relative_root_path = cmdline.GetSwitchValuePath(kSwitchRoot);
+ if (!relative_root_path.empty()) {
+ root_path = base::MakeAbsoluteFilePath(relative_root_path);
+ dotfile_name_ = root_path.Append(kGnFile);
+ } else {
+ base::FilePath cur_dir;
+ file_util::GetCurrentDirectory(&cur_dir);
+ dotfile_name_ = FindDotFile(cur_dir);
+ if (dotfile_name_.empty()) {
+ Err(Location(), "Can't find source root.",
+ "I could not find a \".gn\" file in the current directory or any "
+ "parent,\nand the --root command-line argument was not specified.")
+ .PrintToStdout();
+ return false;
+ }
+ root_path = dotfile_name_.DirName();
+ }
+
+ if (scheduler_.verbose_logging())
+ scheduler_.Log("Using source root", FilePathToUTF8(root_path));
+ build_settings_.set_root_path(root_path);
+
+ return true;
+}
+
+bool Setup::RunConfigFile() {
+ if (scheduler_.verbose_logging())
+ scheduler_.Log("Got dotfile", FilePathToUTF8(dotfile_name_));
+
+ dotfile_input_file_.reset(new InputFile(SourceFile("//.gn")));
+ if (!dotfile_input_file_->Load(dotfile_name_)) {
+ Err(Location(), "Could not load dotfile.",
+ "The file \"" + FilePathToUTF8(dotfile_name_) + "\" cound't be loaded")
+ .PrintToStdout();
+ return false;
+ }
+
+ Err err;
+ dotfile_tokens_ = Tokenizer::Tokenize(dotfile_input_file_.get(), &err);
+ if (err.has_error()) {
+ err.PrintToStdout();
+ return false;
+ }
+
+ dotfile_root_ = Parser::Parse(dotfile_tokens_, &err);
+ if (err.has_error()) {
+ err.PrintToStdout();
+ return false;
+ }
+
+ dotfile_root_->AsBlock()->ExecuteBlockInScope(&dotfile_scope_, &err);
+ if (err.has_error()) {
+ err.PrintToStdout();
+ return false;
+ }
+
+ return true;
+}
+
+bool Setup::FillOtherConfig(const CommandLine& cmdline) {
+ Err err;
+
+ // Secondary source path.
+ SourceDir secondary_source;
+ if (cmdline.HasSwitch(kSecondarySource)) {
+ // Prefer the command line over the config file.
+ secondary_source =
+ SourceDir(cmdline.GetSwitchValueASCII(kSecondarySource));
+ } else {
+ // Read from the config file if present.
+ const Value* secondary_value =
+ dotfile_scope_.GetValue("secondary_source", true);
+ if (secondary_value) {
+ if (!secondary_value->VerifyTypeIs(Value::STRING, &err)) {
+ err.PrintToStdout();
+ return false;
+ }
+ build_settings_.SetSecondarySourcePath(
+ SourceDir(secondary_value->string_value()));
+ }
+ }
+
+ // Build config dir.
+ const Value* build_config_value =
+ dotfile_scope_.GetValue("buildconfig", true);
+ if (!build_config_value) {
+ Err(Location(), "No build config file.",
+ "Your .gn file (\"" + FilePathToUTF8(dotfile_name_) + "\")\n"
+ "didn't specify a \"buildconfig\" value.").PrintToStdout();
+ return false;
+ }
+ build_settings_.set_build_config_file(
+ SourceFile("//build/config/BUILDCONFIG.gn"));
+
+ return true;
+}
diff --git a/tools/gn/setup.h b/tools/gn/setup.h
new file mode 100644
index 0000000..e698ac5
--- /dev/null
+++ b/tools/gn/setup.h
@@ -0,0 +1,69 @@
+// 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_SETUP_H_
+#define TOOLS_GN_SETUP_H_
+
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/files/file_path.h"
+#include "base/memory/scoped_ptr.h"
+#include "tools/gn/build_settings.h"
+#include "tools/gn/scheduler.h"
+#include "tools/gn/scope.h"
+#include "tools/gn/settings.h"
+#include "tools/gn/token.h"
+#include "tools/gn/toolchain.h"
+
+class CommandLine;
+class InputFile;
+class ParseNode;
+
+// Helper class to setup the build settings and environment for the various
+// commands to run.
+class Setup {
+ public:
+ Setup();
+ ~Setup();
+
+ // Configures the build for the current command line. On success returns
+ // true. On failure, prints the error and returns false.
+ bool DoSetup();
+
+ // Runs the load, returning true on success. On failure, prints the error
+ // and returns false.
+ bool Run();
+
+ BuildSettings& build_settings() { return build_settings_; }
+ Scheduler& scheduler() { return scheduler_; }
+
+ private:
+ // Fills the root directory into the settings. Returns true on success.
+ bool FillSourceDir(const CommandLine& cmdline);
+
+ // Run config file.
+ bool RunConfigFile();
+
+ bool FillOtherConfig(const CommandLine& cmdline);
+
+ BuildSettings build_settings_;
+ Scheduler scheduler_;
+
+ // State for invoking the dotfile.
+ // TODO(brettw) this seems a bit excessive, maybe we can get this down
+ // somehow?
+ base::FilePath dotfile_name_;
+ scoped_ptr<InputFile> dotfile_input_file_;
+ std::vector<Token> dotfile_tokens_;
+ scoped_ptr<ParseNode> dotfile_root_;
+ BuildSettings dotfile_build_settings_;
+ Toolchain dotfile_toolchain_;
+ Settings dotfile_settings_;
+ Scope dotfile_scope_;
+
+ DISALLOW_COPY_AND_ASSIGN(Setup);
+};
+
+#endif // TOOLS_GN_SETUP_H_
diff --git a/tools/gn/source_dir.cc b/tools/gn/source_dir.cc
new file mode 100644
index 0000000..5739b52
--- /dev/null
+++ b/tools/gn/source_dir.cc
@@ -0,0 +1,98 @@
+// 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/source_dir.h"
+
+#include "base/logging.h"
+#include "tools/gn/filesystem_utils.h"
+#include "tools/gn/source_file.h"
+
+namespace {
+
+void AssertValueSourceDirString(const std::string& s) {
+ DCHECK(!s.empty());
+ DCHECK(s[0] == '/');
+ DCHECK(EndsWithSlash(s));
+}
+
+} // namespace
+
+SourceDir::SourceDir() {
+}
+
+SourceDir::SourceDir(const base::StringPiece& p)
+ : value_(p.data(), p.size()) {
+ if (!EndsWithSlash(value_))
+ value_.push_back('/');
+ AssertValueSourceDirString(value_);
+}
+
+SourceDir::~SourceDir() {
+}
+
+SourceFile SourceDir::ResolveRelativeFile(const base::StringPiece& p) const {
+ SourceFile ret;
+
+ // It's an error to resolve an empty string or one that is a directory
+ // (indicated by a trailing slash) because this is the function that expects
+ // to return a file.
+ if (p.empty() || (p.size() > 0 && p[p.size() - 1] == '/'))
+ return SourceFile();
+ if (p[0] == '/') {
+ // Absolute path.
+ ret.value_.assign(p.data(), p.size());
+ return ret;
+ }
+
+ ret.value_.reserve(value_.size() + p.size());
+ ret.value_.assign(value_);
+ ret.value_.append(p.data(), p.size());
+
+ NormalizePath(&ret.value_);
+ return ret;
+}
+
+SourceDir SourceDir::ResolveRelativeDir(const base::StringPiece& p) const {
+ SourceDir ret;
+
+ if (p.empty())
+ return ret;
+ if (p[0] == '/') {
+ // Absolute path.
+ return SourceDir(p);
+ }
+
+ ret.value_.reserve(value_.size() + p.size());
+ ret.value_.assign(value_);
+ ret.value_.append(p.data(), p.size());
+
+ NormalizePath(&ret.value_);
+ if (!EndsWithSlash(ret.value_))
+ ret.value_.push_back('/');
+ AssertValueSourceDirString(ret.value_);
+
+ return ret;
+}
+
+base::FilePath SourceDir::Resolve(const base::FilePath& source_root) const {
+ if (is_null())
+ return base::FilePath();
+
+ std::string converted;
+ if (is_system_absolute()) {
+ converted = value_;
+ ConvertPathToSystem(&converted);
+ return base::FilePath(UTF8ToFilePath(converted));
+ }
+
+ // String the double-leading slash for source-relative paths.
+ converted.assign(&value_[2], value_.size() - 2);
+ ConvertPathToSystem(&converted);
+ return source_root.Append(UTF8ToFilePath(converted));
+}
+
+void SourceDir::SwapInValue(std::string* v) {
+ value_.swap(*v);
+ AssertValueSourceDirString(value_);
+}
diff --git a/tools/gn/source_dir.h b/tools/gn/source_dir.h
new file mode 100644
index 0000000..3b6caee
--- /dev/null
+++ b/tools/gn/source_dir.h
@@ -0,0 +1,104 @@
+// 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_SOURCE_DIR_H_
+#define TOOLS_GN_SOURCE_DIR_H_
+
+#include <string>
+
+#include "base/containers/hash_tables.h"
+#include "base/files/file_path.h"
+#include "base/logging.h"
+#include "base/strings/string_piece.h"
+
+class SourceFile;
+
+// Represents a directory within the source tree. Source dirs begin and end in
+// slashes.
+//
+// If there is one slash at the beginning, it will mean a system-absolute file
+// path. On Windows, absolute system paths will be of the form "/C:/foo/bar".
+//
+// Two slashes at the beginning indicate a path relative to the source root.
+class SourceDir {
+ public:
+ SourceDir();
+ explicit SourceDir(const base::StringPiece& p);
+ ~SourceDir();
+
+ // Resolves a file or dir name relative to this source directory. Will return
+ // an empty SourceDir/File on error. Empty input is always an error (it's
+ // possible we should say ResolveRelativeDir vs. an empty string should be
+ // the source dir, but we require "." instead).
+ SourceFile ResolveRelativeFile(const base::StringPiece& p) const;
+ SourceDir ResolveRelativeDir(const base::StringPiece& p) const;
+
+ // Resolves this source file relative to some given source root. Returns
+ // an empty file path on error.
+ base::FilePath Resolve(const base::FilePath& source_root) const;
+
+ bool is_null() const { return value_.empty(); }
+ const std::string& value() const { return value_; }
+
+ // Returns true if this path starts with a "//" which indicates a path
+ // from the source root.
+ bool is_source_absolute() const {
+ return value_.size() >= 2 && value_[0] == '/' && value_[1] == '/';
+ }
+
+ // Returns true if this path starts with a single slash which indicates a
+ // system-absolute path.
+ bool is_system_absolute() const {
+ return !is_source_absolute();
+ }
+
+ // Returns a source-absolute path starting with only one slash at the
+ // beginning (normally source-absolute paths start with two slashes to mark
+ // them as such). This is normally used when concatenating directories
+ // together.
+ //
+ // This function asserts that the directory is actually source-absolute. The
+ // return value points into our buffer.
+ base::StringPiece SourceAbsoluteWithOneSlash() const {
+ CHECK(is_source_absolute());
+ return base::StringPiece(&value_[1], value_.size() - 1);
+ }
+
+ void SwapInValue(std::string* v);
+
+ bool operator==(const SourceDir& other) const {
+ return value_ == other.value_;
+ }
+ bool operator!=(const SourceDir& other) const {
+ return !operator==(other);
+ }
+ bool operator<(const SourceDir& other) const {
+ return value_ < other.value_;
+ }
+
+ private:
+ friend class SourceFile;
+ std::string value_;
+
+ // Copy & assign supported.
+};
+
+namespace BASE_HASH_NAMESPACE {
+
+#if defined(COMPILER_GCC)
+template<> struct hash<SourceDir> {
+ std::size_t operator()(const SourceDir& v) const {
+ hash<std::string> h;
+ return h(v.value());
+ }
+};
+#elif defined(COMPILER_MSVC)
+inline size_t hash_value(const SourceDir& v) {
+ return hash_value(v.value());
+}
+#endif // COMPILER...
+
+} // namespace BASE_HASH_NAMESPACE
+
+#endif // TOOLS_GN_SOURCE_DIR_H_
diff --git a/tools/gn/source_dir_unittest.cc b/tools/gn/source_dir_unittest.cc
new file mode 100644
index 0000000..745513d
--- /dev/null
+++ b/tools/gn/source_dir_unittest.cc
@@ -0,0 +1,45 @@
+// 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/source_dir.h"
+#include "tools/gn/source_file.h"
+
+TEST(SourceDir, ResolveRelativeFile) {
+ SourceDir base("//base/");
+
+ // Empty input is an error.
+ EXPECT_TRUE(base.ResolveRelativeFile("") == SourceFile());
+
+ // These things are directories, so should be an error.
+ EXPECT_TRUE(base.ResolveRelativeFile("//foo/bar/") == SourceFile());
+ EXPECT_TRUE(base.ResolveRelativeFile("bar/") == SourceFile());
+
+ // Absolute paths should be passed unchanged.
+ EXPECT_TRUE(base.ResolveRelativeFile("//foo") == SourceFile("//foo"));
+ EXPECT_TRUE(base.ResolveRelativeFile("/foo") == SourceFile("/foo"));
+
+ // Basic relative stuff.
+ EXPECT_TRUE(base.ResolveRelativeFile("foo") == SourceFile("//base/foo"));
+ EXPECT_TRUE(base.ResolveRelativeFile("./foo") == SourceFile("//base/foo"));
+ EXPECT_TRUE(base.ResolveRelativeFile("../foo") == SourceFile("//foo"));
+ EXPECT_TRUE(base.ResolveRelativeFile("../../foo") == SourceFile("//foo"));
+}
+
+TEST(SourceDir, ResolveRelativeDir) {
+ SourceDir base("//base/");
+
+ // Empty input is an error.
+ EXPECT_TRUE(base.ResolveRelativeDir("") == SourceDir());
+
+ // Absolute paths should be passed unchanged.
+ EXPECT_TRUE(base.ResolveRelativeDir("//foo") == SourceDir("//foo/"));
+ EXPECT_TRUE(base.ResolveRelativeDir("/foo") == SourceDir("/foo/"));
+
+ // Basic relative stuff.
+ EXPECT_TRUE(base.ResolveRelativeDir("foo") == SourceDir("//base/foo/"));
+ EXPECT_TRUE(base.ResolveRelativeDir("./foo") == SourceDir("//base/foo/"));
+ EXPECT_TRUE(base.ResolveRelativeDir("../foo") == SourceDir("//foo/"));
+ EXPECT_TRUE(base.ResolveRelativeDir("../../foo/") == SourceDir("//foo/"));
+}
diff --git a/tools/gn/source_file.cc b/tools/gn/source_file.cc
new file mode 100644
index 0000000..de07de1
--- /dev/null
+++ b/tools/gn/source_file.cc
@@ -0,0 +1,67 @@
+// 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/source_file.h"
+
+#include "base/logging.h"
+#include "build/build_config.h"
+#include "tools/gn/filesystem_utils.h"
+#include "tools/gn/source_dir.h"
+
+SourceFile::SourceFile() {
+}
+
+SourceFile::SourceFile(const base::StringPiece& p)
+ : value_(p.data(), p.size()) {
+ DCHECK(!value_.empty());
+ DCHECK(value_[0] == '/');
+ DCHECK(!EndsWithSlash(value_));
+}
+
+SourceFile::~SourceFile() {
+}
+
+std::string SourceFile::GetName() const {
+ if (is_null())
+ return std::string();
+
+ DCHECK(value_.find('/') != std::string::npos);
+ size_t last_slash = value_.rfind('/');
+ return std::string(&value_[last_slash + 1],
+ value_.size() - last_slash - 1);
+}
+
+SourceDir SourceFile::GetDir() const {
+ if (is_null())
+ return SourceDir();
+
+ DCHECK(value_.find('/') != std::string::npos);
+ size_t last_slash = value_.rfind('/');
+ return SourceDir(base::StringPiece(&value_[0], last_slash + 1));
+}
+
+base::FilePath SourceFile::Resolve(const base::FilePath& source_root) const {
+ if (is_null())
+ return base::FilePath();
+
+ std::string converted;
+#if defined(OS_WIN)
+ if (is_system_absolute()) {
+ converted.assign(&value_[1], value_.size() - 1);
+ DCHECK(converted.size() > 2 && converted[1] == ':')
+ << "Expecting Windows absolute file path with a drive letter: "
+ << value_;
+ return base::FilePath(UTF8ToFilePath(converted));
+ }
+
+ converted.assign(&value_[2], value_.size() - 2);
+ ConvertPathToSystem(&converted);
+ return root_path_.Append(UTF8ToFilePath(converted));
+#else
+ if (is_system_absolute())
+ return base::FilePath(value_);
+ converted.assign(&value_[2], value_.size() - 2);
+ return source_root.Append(converted);
+#endif
+}
diff --git a/tools/gn/source_file.h b/tools/gn/source_file.h
new file mode 100644
index 0000000..d883bc0
--- /dev/null
+++ b/tools/gn/source_file.h
@@ -0,0 +1,97 @@
+// 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_SOURCE_FILE_H_
+#define TOOLS_GN_SOURCE_FILE_H_
+
+#include <string>
+
+#include "base/containers/hash_tables.h"
+#include "base/files/file_path.h"
+#include "base/logging.h"
+#include "base/strings/string_piece.h"
+
+class SourceDir;
+
+// Represents a file within the source tree. Always begins in a slash, never
+// ends in one.
+class SourceFile {
+ public:
+ SourceFile();
+
+ // Takes a known absolute source file. Always begins in a slash.
+ explicit SourceFile(const base::StringPiece& p);
+
+ ~SourceFile();
+
+ bool is_null() const { return value_.empty(); }
+ const std::string& value() const { return value_; }
+
+ // Returns everythign after the last slash.
+ std::string GetName() const;
+ SourceDir GetDir() const;
+
+ // Resolves this source file relative to some given source root. Returns
+ // an empty file path on error.
+ base::FilePath Resolve(const base::FilePath& source_root) const;
+
+ // Returns true if this file starts with a "//" which indicates a path
+ // from the source root.
+ bool is_source_absolute() const {
+ return value_.size() >= 2 && value_[0] == '/' && value_[1] == '/';
+ }
+
+ // Returns true if this file starts with a single slash which indicates a
+ // system-absolute path.
+ bool is_system_absolute() const {
+ return !is_source_absolute();
+ }
+
+ // Returns a source-absolute path starting with only one slash at the
+ // beginning (normally source-absolute paths start with two slashes to mark
+ // them as such). This is normally used when concatenating names together.
+ //
+ // This function asserts that the file is actually source-absolute. The
+ // return value points into our buffer.
+ base::StringPiece SourceAbsoluteWithOneSlash() const {
+ CHECK(is_source_absolute());
+ return base::StringPiece(&value_[1], value_.size() - 1);
+ }
+
+ bool operator==(const SourceFile& other) const {
+ return value_ == other.value_;
+ }
+ bool operator!=(const SourceFile& other) const {
+ return !operator==(other);
+ }
+ bool operator<(const SourceFile& other) const {
+ return value_ < other.value_;
+ }
+
+ private:
+ friend class SourceDir;
+
+ std::string value_;
+
+ // Copy & assign supported.
+};
+
+namespace BASE_HASH_NAMESPACE {
+
+#if defined(COMPILER_GCC)
+template<> struct hash<SourceFile> {
+ std::size_t operator()(const SourceFile& v) const {
+ hash<std::string> h;
+ return h(v.value());
+ }
+};
+#elif defined(COMPILER_MSVC)
+inline size_t hash_value(const SourceFile& v) {
+ return hash_value(v.value());
+}
+#endif // COMPILER...
+
+} // namespace BASE_HASH_NAMESPACE
+
+#endif // TOOLS_GN_SOURCE_FILE_H_
diff --git a/tools/gn/standard_out.cc b/tools/gn/standard_out.cc
new file mode 100644
index 0000000..f6a2031
--- /dev/null
+++ b/tools/gn/standard_out.cc
@@ -0,0 +1,84 @@
+// 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/standard_out.h"
+
+#include "build/build_config.h"
+
+#if defined(OS_WIN)
+#include <windows.h>
+#else
+#include <stdio.h>
+#endif
+
+namespace {
+
+bool initialized = false;
+
+#if defined(OS_WIN)
+HANDLE hstdout;
+WORD default_attributes;
+
+bool is_console = false;
+#endif
+
+void EnsureInitialized() {
+ if (initialized)
+ return;
+ initialized = true;
+
+#if defined(OS_WIN)
+ hstdout = ::GetStdHandle(STD_OUTPUT_HANDLE);
+ CONSOLE_SCREEN_BUFFER_INFO info;
+ is_console = !!::GetConsoleScreenBufferInfo(hstdout, &info);
+ default_attributes = info.wAttributes;
+#endif
+}
+
+} // namespace
+
+#if defined(OS_WIN)
+
+void OutputString(const std::string& output, TextDecoration dec) {
+ EnsureInitialized();
+ if (is_console) {
+ switch (dec) {
+ case DECORATION_NONE:
+ break;
+ case DECORATION_BOLD:
+ ::SetConsoleTextAttribute(hstdout, FOREGROUND_INTENSITY);
+ break;
+ case DECORATION_RED:
+ ::SetConsoleTextAttribute(hstdout,
+ FOREGROUND_RED | FOREGROUND_INTENSITY);
+ break;
+ case DECORATION_GREEN:
+ // Keep green non-bold.
+ ::SetConsoleTextAttribute(hstdout, FOREGROUND_GREEN);
+ break;
+ case DECORATION_BLUE:
+ ::SetConsoleTextAttribute(hstdout,
+ FOREGROUND_BLUE | FOREGROUND_INTENSITY);
+ break;
+ case DECORATION_YELLOW:
+ ::SetConsoleTextAttribute(hstdout,
+ FOREGROUND_RED | FOREGROUND_GREEN);
+ break;
+ }
+ }
+
+ DWORD written = 0;
+ ::WriteFile(hstdout, output.c_str(), output.size(), &written, NULL);
+
+ if (is_console)
+ ::SetConsoleTextAttribute(hstdout, default_attributes);
+}
+
+#else
+
+void OutputString(const std::string& output, TextDecoration dec) {
+ printf("%s", output.c_str());
+}
+
+#endif
diff --git a/tools/gn/standard_out.h b/tools/gn/standard_out.h
new file mode 100644
index 0000000..2eb525b
--- /dev/null
+++ b/tools/gn/standard_out.h
@@ -0,0 +1,22 @@
+// 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_STANDARD_OUT_H_
+#define TOOLS_GN_STANDARD_OUT_H_
+
+#include <string>
+
+enum TextDecoration {
+ DECORATION_NONE = 0,
+ DECORATION_BOLD,
+ DECORATION_RED,
+ DECORATION_GREEN,
+ DECORATION_BLUE,
+ DECORATION_YELLOW
+};
+
+void OutputString(const std::string& output,
+ TextDecoration dec = DECORATION_NONE);
+
+#endif // TOOLS_GN_STANDARD_OUT_H_
diff --git a/tools/gn/string_utils.cc b/tools/gn/string_utils.cc
new file mode 100644
index 0000000..14d296a
--- /dev/null
+++ b/tools/gn/string_utils.cc
@@ -0,0 +1,168 @@
+// 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/string_utils.h"
+
+#include "tools/gn/err.h"
+#include "tools/gn/scope.h"
+#include "tools/gn/token.h"
+#include "tools/gn/tokenizer.h"
+#include "tools/gn/value.h"
+
+namespace {
+
+// Constructs an Err indicating a range inside a string. We assume that the
+// token has quotes around it that are not counted by the offset.
+Err ErrInsideStringToken(const Token& token, size_t offset, size_t size,
+ const std::string& msg,
+ const std::string& help = std::string()) {
+ // The "+1" is skipping over the " at the beginning of the token.
+ Location begin_loc(token.location().file(),
+ token.location().line_number(),
+ token.location().char_offset() + offset + 1);
+ Location end_loc(token.location().file(),
+ token.location().line_number(),
+ token.location().char_offset() + offset + 1 + size);
+ return Err(LocationRange(begin_loc, end_loc), msg, help);
+}
+
+// Given the character input[i] indicating the $ in a string, locates the
+// identifier and places its range in |*identifier|, and updates |*i| to
+// point to the last character consumed.
+//
+// On error returns false and sets the error.
+bool LocateInlineIdenfitier(const Token& token,
+ const char* input, size_t size,
+ size_t* i,
+ base::StringPiece* identifier,
+ Err* err) {
+ size_t dollars_index = *i;
+ (*i)++;
+ if (*i == size) {
+ *err = ErrInsideStringToken(token, dollars_index, 1, "$ at end of string.",
+ "I was expecting an identifier after the $.");
+ return false;
+ }
+
+ bool has_brackets;
+ if (input[*i] == '{') {
+ (*i)++;
+ if (*i == size) {
+ *err = ErrInsideStringToken(token, dollars_index, 2,
+ "${ at end of string.",
+ "I was expecting an identifier inside the ${...}.");
+ return false;
+ }
+ has_brackets = true;
+ } else {
+ has_brackets = false;
+ }
+
+ // First char is special.
+ if (!Tokenizer::IsIdentifierFirstChar(input[*i])) {
+ *err = ErrInsideStringToken(
+ token, dollars_index, *i - dollars_index + 1,
+ "$ not followed by an identifier char.",
+ "It you want a literal $ use \"\\$\".");
+ return false;
+ }
+ size_t begin_offset = *i;
+ (*i)++;
+
+ // Find the first non-identifier char following the string.
+ while (*i < size && Tokenizer::IsIdentifierContinuingChar(input[*i]))
+ (*i)++;
+ size_t end_offset = *i;
+
+ // If we started with a bracket, validate that there's an ending one. Leave
+ // *i pointing to the last char we consumed (backing up one).
+ if (has_brackets) {
+ if (*i == size) {
+ *err = ErrInsideStringToken(token, dollars_index, *i - dollars_index,
+ "Unterminated ${...");
+ return false;
+ } else if (input[*i] != '}') {
+ *err = ErrInsideStringToken(token, *i, 1, "Not an identifier in string expansion.",
+ "The contents of ${...} should be an identifier. "
+ "This character is out of sorts.");
+ return false;
+ }
+ // We want to consume the bracket but also back up one, so *i is unchanged.
+ } else {
+ (*i)--;
+ }
+
+ *identifier = base::StringPiece(&input[begin_offset],
+ end_offset - begin_offset);
+ return true;
+}
+
+bool AppendIdentifierValue(Scope* scope,
+ const Token& token,
+ const base::StringPiece& identifier,
+ std::string* output,
+ Err* err) {
+ const Value* value = scope->GetValue(identifier, true);
+ if (!value) {
+ // We assume the identifier points inside the token.
+ *err = ErrInsideStringToken(
+ token, identifier.data() - token.value().data() - 1, identifier.size(),
+ "Undefined identifier in string expansion.",
+ std::string("\"") + identifier + "\" is not currently in scope.");
+ return false;
+ }
+
+ output->append(value->ToString());
+ return true;
+}
+
+} // namespace
+
+bool ExpandStringLiteral(Scope* scope,
+ const Token& literal,
+ Value* result,
+ Err* err) {
+ DCHECK(literal.type() == Token::STRING);
+ DCHECK(literal.value().size() > 1); // Should include quotes.
+ DCHECK(result->type() == Value::STRING); // Should be already set.
+
+ // The token includes the surrounding quotes, so strip those off.
+ const char* input = &literal.value().data()[1];
+ size_t size = literal.value().size() - 2;
+
+ std::string& output = result->string_value();
+ output.reserve(size);
+ for (size_t i = 0; i < size; i++) {
+ if (input[i] == '\\') {
+ if (i < size - 1) {
+ switch (input[i + 1]) {
+ case '\\':
+ case '"':
+ case '$':
+ output.push_back(input[i + 1]);
+ i++;
+ continue;
+ default: // Everything else has no meaning: pass the literal.
+ break;
+ }
+ }
+ output.push_back(input[i]);
+ } else if (input[i] == '$') {
+ base::StringPiece identifier;
+ if (!LocateInlineIdenfitier(literal, input, size, &i, &identifier, err))
+ return false;
+ if (!AppendIdentifierValue(scope, literal, identifier, &output, err))
+ return false;
+ } else {
+ output.push_back(input[i]);
+ }
+ }
+ return true;
+}
+
+std::string RemovePrefix(const std::string& str, const std::string& prefix) {
+ CHECK(str.size() >= prefix.size() &&
+ str.compare(0, prefix.size(), prefix) == 0);
+ return str.substr(prefix.size());
+}
diff --git a/tools/gn/string_utils.h b/tools/gn/string_utils.h
new file mode 100644
index 0000000..7fff1d8
--- /dev/null
+++ b/tools/gn/string_utils.h
@@ -0,0 +1,51 @@
+// 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_STRING_UTILS_H_
+#define TOOLS_GN_STRING_UTILS_H_
+
+#include "base/strings/string_piece.h"
+
+class Err;
+class Scope;
+class Token;
+class Value;
+
+inline std::string operator+(const std::string& a, const base::StringPiece& b) {
+ std::string ret;
+ ret.reserve(a.size() + b.size());
+ ret.assign(a);
+ ret.append(b.data(), b.size());
+ return ret;
+}
+
+inline std::string operator+(const base::StringPiece& a, const std::string& b) {
+ std::string ret;
+ ret.reserve(a.size() + b.size());
+ ret.assign(a.data(), a.size());
+ ret.append(b);
+ return ret;
+}
+
+// Unescapes and expands variables in the given literal, writing the result
+// to the given value. On error, sets |err| and returns false.
+bool ExpandStringLiteral(Scope* scope,
+ const Token& literal,
+ Value* result,
+ Err* err);
+
+// Removes the given prefix from the string. Asserts if the string does
+// not have the given prefix.
+//
+// Note: could potentially return a StringPiece into the str.
+std::string RemovePrefix(const std::string& str, const std::string& prefix);
+
+// Appends the given string piece to the given string. This avoids an
+// intermediate copy.
+inline void AppendStringPiece(std::string* dest,
+ const base::StringPiece& piece) {
+ dest->append(piece.data(), piece.size());
+}
+
+#endif // TOOLS_GN_STRING_UTILS_H_
diff --git a/tools/gn/string_utils_unittest.cc b/tools/gn/string_utils_unittest.cc
new file mode 100644
index 0000000..81181d2
--- /dev/null
+++ b/tools/gn/string_utils_unittest.cc
@@ -0,0 +1,71 @@
+// 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/err.h"
+#include "tools/gn/scope.h"
+#include "tools/gn/settings.h"
+#include "tools/gn/string_utils.h"
+#include "tools/gn/token.h"
+#include "tools/gn/value.h"
+
+namespace {
+
+bool CheckExpansionCase(const char* input, const char* expected, bool success) {
+ Scope scope(static_cast<const Settings*>(NULL));
+ scope.SetValue("one", Value(NULL, 1), NULL);
+ scope.SetValue("onestring", Value(NULL, "one"), NULL);
+
+ // Construct the string token, which includes the quotes.
+ std::string literal_string;
+ literal_string.push_back('"');
+ literal_string.append(input);
+ literal_string.push_back('"');
+ Token literal(Location(), Token::STRING, literal_string);
+
+ Value result(NULL, Value::STRING);
+ Err err;
+ bool ret = ExpandStringLiteral(&scope, literal, &result, &err);
+
+ // Err and return value should agree.
+ EXPECT_NE(ret, err.has_error());
+
+ if (ret != success)
+ return false;
+
+ if (!success)
+ return true; // Don't check result on failure.
+ return result.string_value() == expected;
+}
+
+} // namespace
+
+TEST(StringUtils, ExpandStringLiteral) {
+ EXPECT_TRUE(CheckExpansionCase("", "", true));
+ EXPECT_TRUE(CheckExpansionCase("hello", "hello", true));
+ EXPECT_TRUE(CheckExpansionCase("hello #$one", "hello #1", true));
+ EXPECT_TRUE(CheckExpansionCase("hello #$one/two", "hello #1/two", true));
+ EXPECT_TRUE(CheckExpansionCase("hello #${one}", "hello #1", true));
+ EXPECT_TRUE(CheckExpansionCase("hello #${one}one", "hello #1one", true));
+ EXPECT_TRUE(CheckExpansionCase("hello #${one}$one", "hello #11", true));
+ EXPECT_TRUE(CheckExpansionCase("$onestring${one}$one", "one11", true));
+
+ // Errors
+ EXPECT_TRUE(CheckExpansionCase("hello #$", NULL, false));
+ EXPECT_TRUE(CheckExpansionCase("hello #$%", NULL, false));
+ EXPECT_TRUE(CheckExpansionCase("hello #${", NULL, false));
+ EXPECT_TRUE(CheckExpansionCase("hello #${}", NULL, false));
+ EXPECT_TRUE(CheckExpansionCase("hello #$nonexistant", NULL, false));
+ EXPECT_TRUE(CheckExpansionCase("hello #${unterminated", NULL, false));
+
+ // Unknown backslash values aren't special.
+ EXPECT_TRUE(CheckExpansionCase("\\", "\\", true));
+ EXPECT_TRUE(CheckExpansionCase("\\b", "\\b", true));
+
+ // Backslashes escape some special things. \"\$\\ -> "$\ Note that gtest
+ // doesn't like this escape sequence so we have to put it out-of-line.
+ const char* in = "\\\"\\$\\\\";
+ const char* out = "\"$\\";
+ EXPECT_TRUE(CheckExpansionCase(in, out, true));
+}
diff --git a/tools/gn/target.cc b/tools/gn/target.cc
new file mode 100644
index 0000000..0936f22
--- /dev/null
+++ b/tools/gn/target.cc
@@ -0,0 +1,94 @@
+// 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/target.h"
+
+#include "base/bind.h"
+#include "tools/gn/scheduler.h"
+
+namespace {
+
+void TargetResolvedThunk(const base::Callback<void(const Target*)>& cb,
+ const Target* t) {
+ cb.Run(t);
+}
+
+} // namespace
+
+Target::Target(const Settings* settings, const Label& label)
+ : Item(label),
+ settings_(settings),
+ output_type_(NONE),
+ generated_(false),
+ generator_function_(NULL) {
+}
+
+Target::~Target() {
+}
+
+Target* Target::AsTarget() {
+ return this;
+}
+
+const Target* Target::AsTarget() const {
+ return this;
+}
+
+void Target::OnResolved() {
+ // Gather info from our dependents we need.
+ for (size_t dep = 0; dep < deps_.size(); dep++) {
+ // All dependent configs get pulled to us, and to our dependents.
+ const std::vector<const Config*>& all =
+ deps_[dep]->all_dependent_configs();
+ for (size_t i = 0; i < all.size(); i++) {
+ configs_.push_back(all[i]);
+ all_dependent_configs_.push_back(all[i]);
+ }
+
+ // Direct dependent configs get pulled only to us.
+ const std::vector<const Config*>& direct =
+ deps_[dep]->direct_dependent_configs();
+ for (size_t i = 0; i < direct.size(); i++)
+ configs_.push_back(direct[i]);
+
+ // Direct dependent libraries.
+ if (deps_[dep]->output_type() == STATIC_LIBRARY ||
+ deps_[dep]->output_type() == SHARED_LIBRARY ||
+ deps_[dep]->output_type() == LOADABLE_MODULE)
+ inherited_libraries_.insert(deps_[dep]);
+
+ // Inherited libraries. DOn't pull transitive libraries from shared
+ // libraries, since obviously those shouldn't be linked directly into
+ // later deps unless explicitly specified.
+ if (deps_[dep]->output_type() != SHARED_LIBRARY &&
+ deps_[dep]->output_type() != LOADABLE_MODULE &&
+ deps_[dep]->output_type() != EXECUTABLE) {
+ const std::set<const Target*> inherited =
+ deps_[dep]->inherited_libraries();
+ for (std::set<const Target*>::const_iterator i = inherited.begin();
+ i != inherited.end(); ++i)
+ inherited_libraries_.insert(*i);
+ }
+ }
+
+ if (!settings_->build_settings()->target_resolved_callback().is_null()) {
+ g_scheduler->ScheduleWork(base::Bind(&TargetResolvedThunk,
+ settings_->build_settings()->target_resolved_callback(),
+ this));
+ }
+}
+
+bool Target::HasBeenGenerated() const {
+ return generated_;
+}
+
+void Target::SetGenerated(const Token* token) {
+ DCHECK(!generated_);
+ generated_ = true;
+ generator_function_ = token;
+}
+
+bool Target::IsLinkable() const {
+ return output_type_ == STATIC_LIBRARY || output_type_ == SHARED_LIBRARY;
+}
diff --git a/tools/gn/target.h b/tools/gn/target.h
new file mode 100644
index 0000000..63d62ae
--- /dev/null
+++ b/tools/gn/target.h
@@ -0,0 +1,145 @@
+// 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_TARGET_H_
+#define TOOLS_GN_TARGET_H_
+
+#include <set>
+#include <string>
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "base/logging.h"
+#include "base/strings/string_piece.h"
+#include "base/synchronization/lock.h"
+#include "tools/gn/config_values.h"
+#include "tools/gn/item.h"
+#include "tools/gn/source_file.h"
+
+class InputFile;
+class Settings;
+class Token;
+
+class Target : public Item {
+ public:
+ enum OutputType {
+ NONE,
+ EXECUTABLE,
+ SHARED_LIBRARY,
+ STATIC_LIBRARY,
+ LOADABLE_MODULE,
+ COPY_FILES,
+ CUSTOM,
+ };
+ typedef std::vector<SourceFile> FileList;
+ typedef std::vector<std::string> StringVector;
+
+ Target(const Settings* settings, const Label& label);
+ virtual ~Target();
+
+ // Item overrides.
+ virtual Target* AsTarget() OVERRIDE;
+ virtual const Target* AsTarget() const OVERRIDE;
+ virtual void OnResolved() OVERRIDE;
+
+ // This flag indicates if we've run the TargetGenerator for this target to
+ // fill out the rest of the values. Once we've done this, we save the
+ // location of the function that started the generating so that we can detect
+ // duplicate declarations.
+ bool HasBeenGenerated() const;
+ void SetGenerated(const Token* token);
+
+ const Settings* settings() const { return settings_; }
+
+ OutputType output_type() const { return output_type_; }
+ void set_output_type(OutputType t) { output_type_ = t; }
+
+ bool IsLinkable() const;
+
+ const FileList& sources() const { return sources_; }
+ void swap_in_sources(FileList* s) { sources_.swap(*s); }
+
+ const FileList& data() const { return data_; }
+ void swap_in_data(FileList* d) { data_.swap(*d); }
+
+ const std::vector<const Target*>& deps() const { return deps_; }
+ void swap_in_deps(std::vector<const Target*>* d) { deps_.swap(*d); }
+
+ // List of configs that this class inherits settings from.
+ const std::vector<const Config*>& configs() const { return configs_; }
+ void swap_in_configs(std::vector<const Config*>* c) { configs_.swap(*c); }
+
+ // List of configs that all dependencies (direct and indirect) of this
+ // target get. These configs are not added to this target.
+ const std::vector<const Config*>& all_dependent_configs() const {
+ return all_dependent_configs_;
+ }
+ void swap_in_all_dependent_configs(std::vector<const Config*>* c) {
+ all_dependent_configs_.swap(*c);
+ }
+
+ // List of configs that targets depending directly on this one get. These
+ // configs are not added to this target.
+ const std::vector<const Config*>& direct_dependent_configs() const {
+ return direct_dependent_configs_;
+ }
+ void swap_in_direct_dependent_configs(std::vector<const Config*>* c) {
+ direct_dependent_configs_.swap(*c);
+ }
+
+ const std::set<const Target*>& inherited_libraries() const {
+ return inherited_libraries_;
+ }
+
+ // This config represents the configuration set directly on this target.
+ ConfigValues& config_values() { return config_values_; }
+ const ConfigValues& config_values() const { return config_values_; }
+
+ const SourceDir& destdir() const { return destdir_; }
+ void set_destdir(const SourceDir& d) { destdir_ = d; }
+
+ const SourceFile& script() const { return script_; }
+ void set_script(const SourceFile& s) { script_ = s; }
+
+ const std::vector<std::string>& script_args() const { return script_args_; }
+ void swap_in_script_args(std::vector<std::string>* sa) {
+ script_args_.swap(*sa);
+ }
+
+ const FileList& outputs() const { return outputs_; }
+ void swap_in_outputs(FileList* s) { outputs_.swap(*s); }
+
+ private:
+ const Settings* settings_;
+ OutputType output_type_;
+
+ FileList sources_;
+ FileList data_;
+ std::vector<const Target*> deps_;
+ std::vector<const Config*> configs_;
+ std::vector<const Config*> all_dependent_configs_;
+ std::vector<const Config*> direct_dependent_configs_;
+
+ // Libraries from transitive deps. Libraries need to be linked only
+ // with the end target (executable, shared library). These do not get
+ // pushed beyond shared library boundaries.
+ std::set<const Target*> inherited_libraries_;
+
+ ConfigValues config_values_;
+
+ SourceDir destdir_;
+
+ // Script target stuff.
+ SourceFile script_;
+ std::vector<std::string> script_args_;
+ FileList outputs_;
+
+ bool generated_;
+ const Token* generator_function_; // Who generated this: for error messages.
+
+ DISALLOW_COPY_AND_ASSIGN(Target);
+};
+
+#endif // TOOLS_GN_TARGET_H_
diff --git a/tools/gn/target_generator.cc b/tools/gn/target_generator.cc
new file mode 100644
index 0000000..90c8fe6
--- /dev/null
+++ b/tools/gn/target_generator.cc
@@ -0,0 +1,334 @@
+// 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/target_generator.h"
+
+#include "base/files/file_path.h"
+#include "base/logging.h"
+#include "tools/gn/build_settings.h"
+#include "tools/gn/config.h"
+#include "tools/gn/config_values_generator.h"
+#include "tools/gn/err.h"
+#include "tools/gn/filesystem_utils.h"
+#include "tools/gn/functions.h"
+#include "tools/gn/input_file.h"
+#include "tools/gn/item_node.h"
+#include "tools/gn/ninja_target_writer.h"
+#include "tools/gn/parse_tree.h"
+#include "tools/gn/scheduler.h"
+#include "tools/gn/scope.h"
+#include "tools/gn/target_manager.h"
+#include "tools/gn/token.h"
+#include "tools/gn/value.h"
+#include "tools/gn/value_extractors.h"
+
+namespace {
+
+bool TypeHasConfigs(Target::OutputType type) {
+ return type == Target::EXECUTABLE ||
+ type == Target::SHARED_LIBRARY ||
+ type == Target::STATIC_LIBRARY ||
+ type == Target::LOADABLE_MODULE;
+}
+
+bool TypeHasConfigValues(Target::OutputType type) {
+ return type == Target::EXECUTABLE ||
+ type == Target::SHARED_LIBRARY ||
+ type == Target::STATIC_LIBRARY ||
+ type == Target::LOADABLE_MODULE;
+}
+
+bool TypeHasSources(Target::OutputType type) {
+ return type != Target::NONE;
+}
+
+bool TypeHasData(Target::OutputType type) {
+ return type != Target::NONE;
+}
+
+bool TypeHasDestDir(Target::OutputType type) {
+ return type == Target::COPY_FILES;
+}
+
+bool TypeHasOutputs(Target::OutputType type) {
+ return type == Target::CUSTOM;
+}
+
+} // namespace
+
+TargetGenerator::TargetGenerator(Target* target,
+ Scope* scope,
+ const Token& function_token,
+ const std::vector<Value>& args,
+ const std::string& output_type,
+ Err* err)
+ : target_(target),
+ scope_(scope),
+ function_token_(function_token),
+ args_(args),
+ output_type_(output_type),
+ err_(err),
+ input_directory_(function_token.location().file()->dir()) {
+}
+
+TargetGenerator::~TargetGenerator() {
+}
+
+void TargetGenerator::Run() {
+ // Output type.
+ Target::OutputType output_type = GetOutputType();
+ target_->set_output_type(output_type);
+ if (err_->has_error())
+ return;
+
+ if (TypeHasConfigs(output_type)) {
+ FillConfigs();
+ FillAllDependentConfigs();
+ FillDirectDependentConfigs();
+ }
+ if (TypeHasSources(output_type))
+ FillSources();
+ if (TypeHasData(output_type))
+ FillData();
+ if (output_type == Target::CUSTOM) {
+ FillScript();
+ FillScriptArgs();
+ }
+ if (TypeHasOutputs(output_type))
+ FillOutputs();
+ FillDependencies(); // All types have dependencies.
+
+ if (TypeHasConfigValues(output_type)) {
+ ConfigValuesGenerator gen(&target_->config_values(), scope_,
+ function_token_, input_directory_, err_);
+ gen.Run();
+ if (err_->has_error())
+ return;
+ }
+
+ if (TypeHasDestDir(output_type))
+ FillDestDir();
+
+ // Set the toolchain as a dependency of the target.
+ // TODO(brettw) currently we lock separately for each config, dep, and
+ // toolchain we add which is bad! Do this in one lock.
+ {
+ ItemTree* tree = &GetBuildSettings()->item_tree();
+ base::AutoLock lock(tree->lock());
+ ItemNode* tc_node =
+ tree->GetExistingNodeLocked(ToolchainLabelForScope(scope_));
+ tree->GetExistingNodeLocked(target_->label())->AddDependency(tc_node);
+ }
+
+ target_->SetGenerated(&function_token_);
+ GetBuildSettings()->target_manager().TargetGenerationComplete(
+ target_->label());
+}
+
+// static
+void TargetGenerator::GenerateTarget(Scope* scope,
+ const Token& function_token,
+ const std::vector<Value>& args,
+ const std::string& output_type,
+ Err* err) {
+ // Name is the argument to the function.
+ if (args.size() != 1u || args[0].type() != Value::STRING) {
+ *err = Err(function_token,
+ "Target generator requires one string argument.",
+ "Otherwise I'm not sure what to call this target.");
+ return;
+ }
+
+ // The location of the target is the directory name with no slash at the end.
+ // FIXME(brettw) validate name.
+ const Label& toolchain_label = ToolchainLabelForScope(scope);
+ Label label(function_token.location().file()->dir(),
+ args[0].string_value(),
+ toolchain_label.dir(), toolchain_label.name());
+
+ if (g_scheduler->verbose_logging())
+ g_scheduler->Log("Generating target", label.GetUserVisibleName(true));
+
+ Target* t = scope->settings()->build_settings()->target_manager().GetTarget(
+ label, function_token.range(), NULL, err);
+ if (err->has_error())
+ return;
+
+ TargetGenerator gen(t, scope, function_token, args, output_type, err);
+ gen.Run();
+}
+
+Target::OutputType TargetGenerator::GetOutputType() const {
+ if (output_type_ == functions::kGroup)
+ return Target::NONE;
+ if (output_type_ == functions::kExecutable)
+ return Target::EXECUTABLE;
+ if (output_type_ == functions::kSharedLibrary)
+ return Target::SHARED_LIBRARY;
+ if (output_type_ == functions::kStaticLibrary)
+ return Target::STATIC_LIBRARY;
+ // TODO(brettw) what does loadable module mean?
+ //if (output_type_ == ???)
+ // return Target::LOADABLE_MODULE;
+ if (output_type_ == functions::kCopy)
+ return Target::COPY_FILES;
+ if (output_type_ == functions::kCustom)
+ return Target::CUSTOM;
+
+ *err_ = Err(function_token_, "Not a known output type",
+ "I am very confused.");
+ return Target::NONE;
+}
+
+void TargetGenerator::FillGenericConfigs(
+ const char* var_name,
+ void (Target::*setter)(std::vector<const Config*>*)) {
+ const Value* value = scope_->GetValue(var_name, true);
+ if (!value)
+ return;
+
+ std::vector<Label> labels;
+ if (!ExtractListOfLabels(*value, input_directory_,
+ ToolchainLabelForScope(scope_), &labels, err_))
+ return;
+
+ std::vector<const Config*> dest_configs;
+ dest_configs.resize(labels.size());
+ for (size_t i = 0; i < labels.size(); i++) {
+ dest_configs[i] = Config::GetConfig(
+ scope_->settings(),
+ value->list_value()[i].origin()->GetRange(),
+ labels[i], target_, err_);
+ if (err_->has_error())
+ return;
+ }
+ (target_->*setter)(&dest_configs);
+}
+
+void TargetGenerator::FillConfigs() {
+ FillGenericConfigs("configs", &Target::swap_in_configs);
+}
+
+void TargetGenerator::FillAllDependentConfigs() {
+ FillGenericConfigs("all_dependent_configs",
+ &Target::swap_in_all_dependent_configs);
+}
+
+void TargetGenerator::FillDirectDependentConfigs() {
+ FillGenericConfigs("direct_dependent_configs",
+ &Target::swap_in_direct_dependent_configs);
+}
+
+void TargetGenerator::FillSources() {
+ const Value* value = scope_->GetValue("sources", true);
+ if (!value)
+ return;
+
+ Target::FileList dest_sources;
+ if (!ExtractListOfRelativeFiles(*value, input_directory_, &dest_sources,
+ err_))
+ return;
+ target_->swap_in_sources(&dest_sources);
+}
+
+void TargetGenerator::FillData() {
+ const Value* value = scope_->GetValue("data", true);
+ if (!value)
+ return;
+
+ Target::FileList dest_data;
+ if (!ExtractListOfRelativeFiles(*value, input_directory_, &dest_data,
+ err_))
+ return;
+ target_->swap_in_data(&dest_data);
+}
+
+void TargetGenerator::FillDependencies() {
+ const Value* value = scope_->GetValue("deps", true);
+ if (!value)
+ return;
+
+ std::vector<Label> labels;
+ if (!ExtractListOfLabels(*value, input_directory_,
+ ToolchainLabelForScope(scope_), &labels, err_))
+ return;
+
+ std::vector<const Target*> dest_deps;
+ dest_deps.resize(labels.size());
+ for (size_t i = 0; i < labels.size(); i++) {
+ dest_deps[i] = GetBuildSettings()->target_manager().GetTarget(
+ labels[i], value->list_value()[i].origin()->GetRange(), target_, err_);
+ if (err_->has_error())
+ return;
+ }
+
+ target_->swap_in_deps(&dest_deps);
+}
+
+void TargetGenerator::FillDestDir() {
+ // Destdir is required for all targets that use it.
+ const Value* value = scope_->GetValue("destdir", true);
+ if (!value) {
+ *err_ = Err(function_token_, "This target type requires a \"destdir\".");
+ return;
+ }
+ if (!value->VerifyTypeIs(Value::STRING, err_))
+ return;
+
+ if (!EnsureStringIsInOutputDir(
+ GetBuildSettings()->build_dir(),
+ value->string_value(), *value, err_))
+ return;
+ target_->set_destdir(SourceDir(value->string_value()));
+}
+
+void TargetGenerator::FillScript() {
+ // If this gets called, the target type requires a script, so error out
+ // if it doesn't have one.
+ const Value* value = scope_->GetValue("script", true);
+ if (!value) {
+ *err_ = Err(function_token_, "This target type requires a \"script\".");
+ return;
+ }
+ if (!value->VerifyTypeIs(Value::STRING, err_))
+ return;
+
+ target_->set_script(
+ input_directory_.ResolveRelativeFile(value->string_value()));
+}
+
+void TargetGenerator::FillScriptArgs() {
+ const Value* value = scope_->GetValue("args", true);
+ if (!value)
+ return;
+
+ std::vector<std::string> args;
+ if (!ExtractListOfStringValues(*value, &args, err_))
+ return;
+ target_->swap_in_script_args(&args);
+}
+
+void TargetGenerator::FillOutputs() {
+ const Value* value = scope_->GetValue("outputs", true);
+ if (!value)
+ return;
+
+ Target::FileList outputs;
+ if (!ExtractListOfRelativeFiles(*value, input_directory_, &outputs, err_))
+ return;
+
+ // Validate that outputs are in the output dir.
+ CHECK(outputs.size() == value->list_value().size());
+ for (size_t i = 0; i < outputs.size(); i++) {
+ if (!EnsureStringIsInOutputDir(
+ GetBuildSettings()->build_dir(),
+ outputs[i].value(), value->list_value()[i], err_))
+ return;
+ }
+ target_->swap_in_outputs(&outputs);
+}
+
+const BuildSettings* TargetGenerator::GetBuildSettings() const {
+ return scope_->settings()->build_settings();
+}
diff --git a/tools/gn/target_generator.h b/tools/gn/target_generator.h
new file mode 100644
index 0000000..11e920c
--- /dev/null
+++ b/tools/gn/target_generator.h
@@ -0,0 +1,83 @@
+// 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_TARGET_GENERATOR_H_
+#define TOOLS_GN_TARGET_GENERATOR_H_
+
+#include <string>
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/gtest_prod_util.h"
+#include "base/memory/scoped_ptr.h"
+#include "tools/gn/source_dir.h"
+#include "tools/gn/target.h"
+
+class BuildSettings;
+class Err;
+class Location;
+class Scope;
+class Token;
+class Value;
+
+// Creates Target objects from a Scope (the result of a script execution).
+class TargetGenerator {
+ public:
+ TargetGenerator(Target* target,
+ Scope* scope,
+ const Token& function_token,
+ const std::vector<Value>& args,
+ const std::string& output_type,
+ Err* err);
+ ~TargetGenerator();
+
+ void Run();
+
+ // The function token is the token of the function name of the generator for
+ // this target. err() will be set on failure.
+ static void GenerateTarget(Scope* scope,
+ const Token& function_token,
+ const std::vector<Value>& args,
+ const std::string& output_type,
+ Err* err);
+
+ private:
+ // Sets err_ on failure.
+ Target::OutputType GetOutputType() const;
+
+ // Reads configs from the given var name, and uses the given setting on the
+ // target to save them
+ void FillGenericConfigs(const char* var_name,
+ void (Target::*setter)(std::vector<const Config*>*));
+
+ void FillConfigs();
+ void FillAllDependentConfigs();
+ void FillDirectDependentConfigs();
+ void FillSources();
+ void FillData();
+ void FillDependencies();
+ void FillDestDir();
+ void FillScript();
+ void FillScriptArgs();
+ void FillOutputs();
+
+ const BuildSettings* GetBuildSettings() const;
+
+ Target* target_;
+ Scope* scope_;
+ const Token& function_token_;
+ std::vector<Value> args_;
+ std::string output_type_;
+ Err* err_;
+
+ // Sources are relative to this. This comes from the input file which doesn't
+ // get freed so we don't acautlly have to make a copy.
+ const SourceDir& input_directory_;
+
+ FRIEND_TEST_ALL_PREFIXES(TargetGenerator, ResolveInputPath);
+
+ DISALLOW_COPY_AND_ASSIGN(TargetGenerator);
+};
+
+#endif // TOOLS_GN_TARGET_GENERATOR_H_
diff --git a/tools/gn/target_generator_unittest.cc b/tools/gn/target_generator_unittest.cc
new file mode 100644
index 0000000..feef6a9
--- /dev/null
+++ b/tools/gn/target_generator_unittest.cc
@@ -0,0 +1,8 @@
+// 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/filesystem_utils.h"
+#include "tools/gn/target_generator.h"
+
diff --git a/tools/gn/target_manager.cc b/tools/gn/target_manager.cc
new file mode 100644
index 0000000..ece9f08
--- /dev/null
+++ b/tools/gn/target_manager.cc
@@ -0,0 +1,134 @@
+// 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/target_manager.h"
+
+#include <deque>
+
+#include "base/bind.h"
+#include "base/strings/string_piece.h"
+#include "tools/gn/build_settings.h"
+#include "tools/gn/err.h"
+#include "tools/gn/filesystem_utils.h"
+#include "tools/gn/item_node.h"
+#include "tools/gn/scheduler.h"
+#include "tools/gn/toolchain_manager.h"
+#include "tools/gn/value.h"
+
+TargetManager::TargetManager(const BuildSettings* build_settings)
+ : build_settings_(build_settings) {
+}
+
+TargetManager::~TargetManager() {
+}
+
+Target* TargetManager::GetTarget(const Label& label,
+ const LocationRange& specified_from_here,
+ Target* dep_from,
+ Err* err) {
+ DCHECK(!label.is_null());
+ DCHECK(!label.toolchain_dir().value().empty());
+ DCHECK(!label.toolchain_name().empty());
+
+ base::AutoLock lock(build_settings_->item_tree().lock());
+
+ ItemNode* target_node =
+ build_settings_->item_tree().GetExistingNodeLocked(label);
+ Target* target = NULL;
+ if (!target_node) {
+ // First time we've seen this, may need to load the file.
+
+ // Compute the settings. The common case is that we have a dep_from and
+ // the toolchains match, so we can use the settings from there rather than
+ // querying the toolchain manager (which requires locking, etc.).
+ const Settings* settings;
+ if (dep_from && dep_from->label().ToolchainsEqual(label)) {
+ settings = dep_from->settings();
+ } else {
+ settings =
+ build_settings_->toolchain_manager().GetSettingsForToolchainLocked(
+ specified_from_here, label.GetToolchainLabel(), err);
+ if (!settings)
+ return NULL;
+ }
+
+ target = new Target(settings, label);
+ target_node = new ItemNode(target);
+ target_node->set_originally_referenced_from_here(specified_from_here);
+ build_settings_->item_tree().AddNodeLocked(target_node);
+
+ // We're generating a node when there is no referencing one.
+ if (!dep_from)
+ target_node->set_generated_from_here(specified_from_here);
+
+ // Only schedule loading the given target if somebody is depending on it
+ // (and we optimize by not re-asking it to run the current file).
+ // Otherwise, we're probably generating it right now.
+ if (dep_from && dep_from->label().dir() != label.dir()) {
+ if (!ScheduleInvocationLocked(specified_from_here, label, err))
+ return NULL;
+ }
+ } else if ((target = target_node->item()->AsTarget())) {
+ // Previously saw this item as a target.
+
+ // If we have no dep_from, we're generating it.
+ if (!dep_from) {
+ // In this case, it had better not already be generated.
+ if (target_node->state() != ItemNode::REFERENCED) {
+ *err = Err(specified_from_here,
+ "Duplicate target.",
+ "\"" + label.GetUserVisibleName(true) +
+ "\" being defined here.");
+ err->AppendSubErr(Err(target_node->generated_from_here(),
+ "Originally defined here."));
+ return NULL;
+ } else {
+ target_node->set_generated_from_here(specified_from_here);
+ }
+ }
+ } else {
+ // Error, we previously saw this thing as a non-target.
+ *err = Err(specified_from_here, "Not previously a target.",
+ "The target being declared here was previously seen referenced as a\n"
+ "non-target (like a config)");
+ err->AppendSubErr(Err(target_node->originally_referenced_from_here(),
+ "Originally referenced from here."));
+ return NULL;
+ }
+
+ // Keep a record of the guy asking us for this dependency. We know if
+ // somebody is adding a dependency, that guy it himself not resolved.
+ if (dep_from && target_node->state() != ItemNode::RESOLVED) {
+ build_settings_->item_tree().GetExistingNodeLocked(
+ dep_from->label())->AddDependency(target_node);
+ }
+
+ return target;
+}
+
+void TargetManager::TargetGenerationComplete(const Label& label) {
+ base::AutoLock lock(build_settings_->item_tree().lock());
+ build_settings_->item_tree().MarkItemGeneratedLocked(label);
+}
+
+void TargetManager::GetAllTargets(
+ std::vector<const Target*>* all_targets) const {
+ base::AutoLock lock(build_settings_->item_tree().lock());
+
+ std::vector<const Item*> all_items;
+ build_settings_->item_tree().GetAllItemsLocked(&all_items);
+ for (size_t i = 0; i < all_items.size(); i++) {
+ const Target* t = all_items[i]->AsTarget();
+ if (t)
+ all_targets->push_back(t);
+ }
+}
+
+bool TargetManager::ScheduleInvocationLocked(
+ const LocationRange& specified_from_here,
+ const Label& label,
+ Err* err) {
+ return build_settings_->toolchain_manager().ScheduleInvocationLocked(
+ specified_from_here, label.GetToolchainLabel(), label.dir(), err);
+}
diff --git a/tools/gn/target_manager.h b/tools/gn/target_manager.h
new file mode 100644
index 0000000..2dd2aed
--- /dev/null
+++ b/tools/gn/target_manager.h
@@ -0,0 +1,73 @@
+// 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_TARGET_MANAGER_H_
+#define TOOLS_GN_TARGET_MANAGER_H_
+
+#include <set>
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/containers/hash_tables.h"
+#include "base/synchronization/lock.h"
+#include "tools/gn/target.h"
+
+class BuildSettings;
+class Err;
+class ItemTree;
+class LocationRange;
+class ToolchainManager;
+class Value;
+
+// Manages all the targets in the system. This integrates with the ItemTree
+// to manage the target-specific rules and creation.
+//
+// This class is threadsafe.
+class TargetManager {
+ public:
+ explicit TargetManager(const BuildSettings* settings);
+ ~TargetManager();
+
+ // Gets a reference to a named target. The given target name is created if
+ // it doesn't exist.
+ //
+ // The label should be fully specified in that it should include an
+ // explicit toolchain.
+ //
+ // |specified_from_here| should indicate the dependency or the target
+ // generator causing this access for error message generation.
+ //
+ // |dep_from| should be set when a target is getting a dep that it depends
+ // on. |dep_from| indicates the target that specified the dependency. It
+ // will be used to track outstanding dependencies so we can know when the
+ // target and all of its dependencies are complete. It should be null when
+ // getting a target for other reasons.
+ //
+ // On failure, |err| will be set.
+ //
+ // The returned pointer must not be dereferenced until it's generated, since
+ // it could be being generated on another thread.
+ Target* GetTarget(const Label& label,
+ const LocationRange& specified_from_here,
+ Target* dep_from,
+ Err* err);
+
+ // Called by a target when it has been loaded from the .gin file. Its
+ // dependencies may or may not be resolved yet.
+ void TargetGenerationComplete(const Label& label);
+
+ // Returns a list of all targets.
+ void GetAllTargets(std::vector<const Target*>* all_targets) const;
+
+ private:
+ bool ScheduleInvocationLocked(const LocationRange& specified_from_here,
+ const Label& label,
+ Err* err);
+
+ const BuildSettings* build_settings_;
+
+ DISALLOW_COPY_AND_ASSIGN(TargetManager);
+};
+
+#endif // TOOLS_GN_TARGET_MANAGER_H
diff --git a/tools/gn/target_manager_unittest.cc b/tools/gn/target_manager_unittest.cc
new file mode 100644
index 0000000..a1a3ad2
--- /dev/null
+++ b/tools/gn/target_manager_unittest.cc
@@ -0,0 +1,95 @@
+// 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/err.h"
+#include "tools/gn/settings.h"
+#include "tools/gn/target_manager.h"
+#include "tools/gn/value.h"
+
+/* TODO(brettw) make this compile again
+namespace {
+
+class TestTargetManagerDelegate : public TargetManager::Delegate {
+ public:
+ TestTargetManagerDelegate() {}
+
+ virtual bool ScheduleInvocation(ToolchainManager* toolchain_manager,
+ const LocationRange& origin,
+ const Label& toolchain_name,
+ const SourceDir& dir,
+ Err* err) OVERRIDE {
+ invokes.push_back(dir.value());
+ return true;
+ }
+ virtual void ScheduleTargetFileWrite(const Target* target) {
+ writes.push_back(target);
+ }
+
+ std::vector<std::string> invokes;
+ std::vector<const Target*> writes;
+};
+
+} // namespace
+
+TEST(TargetManager, ResolveDeps) {
+ TestTargetManagerDelegate ttmd;
+ BuildSettings build_settings(&ttmd);
+
+ TargetManager& target_manager = build_settings.target_manager();
+
+ SourceDir tc_dir("/chrome/");
+ std::string tc_name("toolchain");
+
+ // Get a root target. This should not invoke anything.
+ Err err;
+ Label chromelabel(SourceDir("/chrome/"), "chrome", tc_dir, tc_name);
+ Target* chrome = target_manager.GetTarget(
+ chromelabel, LocationRange(), NULL, &err);
+ EXPECT_EQ(0u, ttmd.invokes.size());
+
+ // Declare it has a dependency on content1 and 2. We should get one
+ // invocation of the content build file.
+ Label content1label(SourceDir("/content/"), "content1", tc_dir, tc_name);
+ Target* content1 = target_manager.GetTarget(
+ content1label, LocationRange(), chrome, &err);
+ EXPECT_EQ(1u, ttmd.invokes.size());
+
+ Label content2label(SourceDir("/content/"), "content2", tc_dir, tc_name);
+ Target* content2 = target_manager.GetTarget(
+ content2label, LocationRange(), chrome, &err);
+ EXPECT_EQ(2u, ttmd.invokes.size());
+
+ // Declare chrome has a depdency on base, this should load it.
+ Label baselabel(SourceDir("/base/"), "base", tc_dir, tc_name);
+ Target* base1 = target_manager.GetTarget(
+ baselabel, LocationRange(), chrome, &err);
+ EXPECT_EQ(3u, ttmd.invokes.size());
+
+ // Declare content1 has a dependency on base.
+ Target* base2 = target_manager.GetTarget(
+ baselabel, LocationRange(), content1, &err);
+ EXPECT_EQ(3u, ttmd.invokes.size());
+ EXPECT_EQ(base1, base2);
+
+ // Mark content1 and chrome as done. They have unresolved depdendencies so
+ // shouldn't be written out yet.
+ target_manager.TargetGenerationComplete(content1label);
+ target_manager.TargetGenerationComplete(chromelabel);
+ EXPECT_EQ(0u, ttmd.writes.size());
+
+ // Mark content2 as done. It has no dependencies so should be written.
+ target_manager.TargetGenerationComplete(content2label);
+ ASSERT_EQ(1u, ttmd.writes.size());
+ EXPECT_EQ(content2label, ttmd.writes[0]->label());
+
+ // Mark base as complete. It should have caused itself, content1 and then
+ // chrome to be written.
+ target_manager.TargetGenerationComplete(baselabel);
+ ASSERT_EQ(4u, ttmd.writes.size());
+ EXPECT_EQ(baselabel, ttmd.writes[1]->label());
+ EXPECT_EQ(content1label, ttmd.writes[2]->label());
+ EXPECT_EQ(chromelabel, ttmd.writes[3]->label());
+}
+*/
diff --git a/tools/gn/token.cc b/tools/gn/token.cc
new file mode 100644
index 0000000..cbce5e7
--- /dev/null
+++ b/tools/gn/token.cc
@@ -0,0 +1,60 @@
+// 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/token.h"
+
+#include "base/logging.h"
+
+namespace {
+
+std::string UnescapeString(const base::StringPiece& input) {
+ std::string result;
+ result.reserve(input.size());
+
+ for (size_t i = 0; i < input.size(); i++) {
+ if (input[i] == '\\') {
+ DCHECK(i < input.size() - 1); // Last char shouldn't be a backslash or
+ // it would have escaped the terminator.
+ i++; // Skip backslash, next char is a literal.
+ }
+ result.push_back(input[i]);
+ }
+ return result;
+}
+
+} // namespace
+
+Token::Token() : type_(INVALID), value_() {
+}
+
+Token::Token(const Location& location,
+ Type t,
+ const base::StringPiece& v)
+ : type_(t),
+ value_(v),
+ location_(location) {
+}
+
+bool Token::IsIdentifierEqualTo(const char* v) const {
+ return type_ == IDENTIFIER && value_ == v;
+}
+
+bool Token::IsOperatorEqualTo(const char* v) const {
+ return type_ == OPERATOR && value_ == v;
+}
+
+bool Token::IsScoperEqualTo(const char* v) const {
+ return type_ == SCOPER && value_ == v;
+}
+
+bool Token::IsStringEqualTo(const char* v) const {
+ return type_ == STRING && value_ == v;
+}
+
+std::string Token::StringValue() const {
+ DCHECK(type() == STRING);
+
+ // Trim off the string terminators at the end.
+ return UnescapeString(value_.substr(1, value_.size() - 2));
+}
diff --git a/tools/gn/token.h b/tools/gn/token.h
new file mode 100644
index 0000000..64b06ea
--- /dev/null
+++ b/tools/gn/token.h
@@ -0,0 +1,52 @@
+// 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_TOKEN_H_
+#define TOOLS_GN_TOKEN_H_
+
+#include "base/strings/string_piece.h"
+#include "tools/gn/location.h"
+
+class Token {
+ public:
+ enum Type {
+ INVALID,
+ INTEGER, // 123
+ STRING, // "blah"
+ OPERATOR, // =, +=, -=, +, -, ==, !=, <=, >=, <, >
+ IDENTIFIER, // foo
+ SCOPER, // (, ), [, ], {, }
+ SEPARATOR, // ,
+ COMMENT // #...\n
+ };
+
+ Token();
+ Token(const Location& location, Type t, const base::StringPiece& v);
+
+ Type type() const { return type_; }
+ const base::StringPiece& value() const { return value_; }
+ const Location& location() const { return location_; }
+ LocationRange range() const {
+ return LocationRange(location_,
+ Location(location_.file(), location_.line_number(),
+ location_.char_offset() + value_.size()));
+ }
+
+ // Helper functions for comparing this token to something.
+ bool IsIdentifierEqualTo(const char* v) const;
+ bool IsOperatorEqualTo(const char* v) const;
+ bool IsScoperEqualTo(const char* v) const;
+ bool IsStringEqualTo(const char* v) const;
+
+ // For STRING tokens, returns the string value (no quotes at end, does
+ // unescaping).
+ std::string StringValue() const;
+
+ private:
+ Type type_;
+ base::StringPiece value_;
+ Location location_;
+};
+
+#endif // TOOLS_GN_TOKEN_H_
diff --git a/tools/gn/tokenizer.cc b/tools/gn/tokenizer.cc
new file mode 100644
index 0000000..971f56b
--- /dev/null
+++ b/tools/gn/tokenizer.cc
@@ -0,0 +1,309 @@
+// 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/tokenizer.h"
+
+#include "base/logging.h"
+#include "tools/gn/input_file.h"
+
+namespace {
+
+bool IsNumberChar(char c) {
+ return c == '-' || (c >= '0' && c <= '9');
+}
+
+bool CouldBeTwoCharOperatorBegin(char c) {
+ return c == '<' || c == '>' || c == '!' || c == '=' || c == '-' ||
+ c == '+' || c == '|' || c == '&';
+}
+
+bool CouldBeTwoCharOperatorEnd(char c) {
+ return c == '=' || c == '|' || c == '&';
+}
+
+bool CouldBeOneCharOperator(char c) {
+ return c == '=' || c == '<' || c == '>' || c == '+' || c == '!' ||
+ c == ':' || c == '|' || c == '&' || c == '-';
+}
+
+bool CouldBeOperator(char c) {
+ return CouldBeOneCharOperator(c) || CouldBeTwoCharOperatorBegin(c);
+}
+
+bool IsSeparatorChar(char c) {
+ return c == ',';
+}
+
+bool IsScoperChar(char c) {
+ return c == '(' || c == ')' || c == '[' || c == ']' || c == '{' || c == '}';
+}
+
+} // namespace
+
+Tokenizer::Tokenizer(const InputFile* input_file, Err* err)
+ : input_file_(input_file),
+ input_(input_file->contents()),
+ err_(err),
+ cur_(0),
+ line_number_(1),
+ char_in_line_(1) {
+}
+
+Tokenizer::~Tokenizer() {
+}
+
+// static
+std::vector<Token> Tokenizer::Tokenize(const InputFile* input_file, Err* err) {
+ Tokenizer t(input_file, err);
+ return t.Run();
+}
+
+std::vector<Token> Tokenizer::Run() {
+ std::vector<Token> tokens;
+ while (!done()) {
+ AdvanceToNextToken();
+ if (done())
+ break;
+ Location location = GetCurrentLocation();
+
+ Token::Type type = ClassifyCurrent();
+ if (type == Token::INVALID) {
+ *err_ = GetErrorForInvalidToken(location);
+ break;
+ }
+ size_t token_begin = cur_;
+ AdvanceToEndOfToken(location, type);
+ if (has_error())
+ break;
+ size_t token_end = cur_;
+
+ // TODO(brettw) This just strips comments from the token stream. This
+ // is probably wrong, they should be removed at a later stage so we can
+ // do things like rewrite the file. But this makes the parser simpler and
+ // is OK for now.
+ if (type != Token::COMMENT) {
+ tokens.push_back(Token(
+ location,
+ type,
+ base::StringPiece(&input_.data()[token_begin],
+ token_end - token_begin)));
+ }
+ }
+ if (err_->has_error())
+ tokens.clear();
+ return tokens;
+}
+
+// static
+size_t Tokenizer::ByteOffsetOfNthLine(const base::StringPiece& buf, int n) {
+ int cur_line = 1;
+ size_t cur_byte = 0;
+
+ DCHECK(n > 0);
+
+ if (n == 1)
+ return 0;
+
+ while (cur_byte < buf.size()) {
+ if (IsNewline(buf, cur_byte)) {
+ cur_line++;
+ if (cur_line == n)
+ return cur_byte + 1;
+ }
+ cur_byte++;
+ }
+ return -1;
+}
+
+// static
+bool Tokenizer::IsNewline(const base::StringPiece& buffer, size_t offset) {
+ DCHECK(offset < buffer.size());
+ // We may need more logic here to handle different line ending styles.
+ return buffer[offset] == '\n';
+}
+
+
+void Tokenizer::AdvanceToNextToken() {
+ while (!at_end() && IsCurrentWhitespace())
+ Advance();
+}
+
+Token::Type Tokenizer::ClassifyCurrent() const {
+ DCHECK(!at_end());
+ char next_char = cur_char();
+ if (next_char >= '0' && next_char <= '9')
+ return Token::INTEGER;
+ if (next_char == '"')
+ return Token::STRING;
+
+ // Note: '-' handled specially below.
+ if (next_char != '-' && CouldBeOperator(next_char))
+ return Token::OPERATOR;
+
+ if (IsIdentifierFirstChar(next_char))
+ return Token::IDENTIFIER;
+
+ if (IsScoperChar(next_char))
+ return Token::SCOPER;
+
+ if (IsSeparatorChar(next_char))
+ return Token::SEPARATOR;
+
+ if (next_char == '#')
+ return Token::COMMENT;
+
+ // For the case of '-' differentiate between a negative number and anything
+ // else.
+ if (next_char == '-') {
+ if (!CanIncrement())
+ return Token::OPERATOR; // Just the minus before end of file.
+ char following_char = input_[cur_ + 1];
+ if (following_char >= '0' && following_char <= '9')
+ return Token::INTEGER;
+ return Token::OPERATOR;
+ }
+
+ return Token::INVALID;
+}
+
+void Tokenizer::AdvanceToEndOfToken(const Location& location,
+ Token::Type type) {
+ switch (type) {
+ case Token::INTEGER:
+ do {
+ Advance();
+ } while (!at_end() && IsNumberChar(cur_char()));
+ if (!at_end()) {
+ // Require the char after a number to be some kind of space, scope,
+ // or operator.
+ char c = cur_char();
+ if (!IsCurrentWhitespace() && !CouldBeOperator(c) &&
+ !IsScoperChar(c) && !IsSeparatorChar(c)) {
+ *err_ = Err(GetCurrentLocation(),
+ "This is not a valid number.",
+ "Learn to count.");
+ // Highlight the number.
+ err_->AppendRange(LocationRange(location, GetCurrentLocation()));
+ }
+ }
+ break;
+
+ case Token::STRING: {
+ char initial = cur_char();
+ Advance(); // Advance past initial "
+ for (;;) {
+ if (at_end()) {
+ *err_ = Err(LocationRange(location,
+ Location(input_file_, line_number_, char_in_line_)),
+ "Unterminated string literal.",
+ "Don't leave me hanging like this!");
+ break;
+ }
+ if (IsCurrentStringTerminator(initial)) {
+ Advance(); // Skip past last "
+ break;
+ } else if (cur_char() == '\n') {
+ *err_ = Err(LocationRange(location,
+ GetCurrentLocation()),
+ "Newline in string constant.");
+ }
+ Advance();
+ }
+ break;
+ }
+
+ case Token::OPERATOR:
+ // Some operators are two characters, some are one.
+ if (CouldBeTwoCharOperatorBegin(cur_char())) {
+ if (CanIncrement() && CouldBeTwoCharOperatorEnd(input_[cur_ + 1]))
+ Advance();
+ }
+ Advance();
+ break;
+
+ case Token::IDENTIFIER:
+ while (!at_end() && IsIdentifierContinuingChar(cur_char()))
+ Advance();
+ break;
+
+ case Token::SCOPER:
+ case Token::SEPARATOR:
+ Advance(); // All are one char.
+ break;
+
+ case Token::COMMENT:
+ // Eat to EOL.
+ while (!at_end() && !IsCurrentNewline())
+ Advance();
+ break;
+
+ case Token::INVALID:
+ *err_ = Err(location, "Everything is all messed up",
+ "Please insert system disk in drive A: and press any key.");
+ NOTREACHED();
+ return;
+ }
+}
+
+bool Tokenizer::IsCurrentWhitespace() const {
+ DCHECK(!at_end());
+ char c = input_[cur_];
+ // Note that tab (0x09) is illegal.
+ return c == 0x0A || c == 0x0B || c == 0x0C || c == 0x0D || c == 0x20;
+}
+
+bool Tokenizer::IsCurrentStringTerminator(char quote_char) const {
+ DCHECK(!at_end());
+ if (cur_char() != quote_char)
+ return false;
+
+ // Check for escaping. \" is not a string terminator, but \\" is. Count
+ // the number of preceeding backslashes.
+ int num_backslashes = 0;
+ for (int i = static_cast<int>(cur_) - 1; i >= 0 && input_[i] == '\\'; i--)
+ num_backslashes++;
+
+ // Even backslashes mean that they were escaping each other and don't count
+ // as escaping this quote.
+ return (num_backslashes % 2) == 0;
+}
+
+bool Tokenizer::IsCurrentNewline() const {
+ return IsNewline(input_, cur_);
+}
+
+void Tokenizer::Advance() {
+ DCHECK(cur_ < input_.size());
+ if (IsCurrentNewline()) {
+ line_number_++;
+ char_in_line_ = 1;
+ } else {
+ char_in_line_++;
+ }
+ cur_++;
+}
+
+Location Tokenizer::GetCurrentLocation() const {
+ return Location(input_file_, line_number_, char_in_line_);
+}
+
+Err Tokenizer::GetErrorForInvalidToken(const Location& location) const {
+ std::string help;
+ if (cur_char() == ';') {
+ // Semicolon.
+ help = "Semicolons are not needed, delete this one.";
+ } else if (cur_char() == '\t') {
+ // Tab.
+ help = "You got a tab character in here. Tabs are evil. "
+ "Convert to spaces.";
+ } else if (cur_char() == '/' && cur_ + 1 < input_.size() &&
+ (input_[cur_ + 1] == '/' || input_[cur_ + 1] == '*')) {
+ // Different types of comments.
+ help = "Comments should start with # instead";
+ } else {
+ help = "I have no idea what this is.";
+ }
+
+ return Err(location, "Invalid token.", help);
+}
diff --git a/tools/gn/tokenizer.h b/tools/gn/tokenizer.h
new file mode 100644
index 0000000..5e00169
--- /dev/null
+++ b/tools/gn/tokenizer.h
@@ -0,0 +1,86 @@
+// 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_TOKENIZER_H_
+#define TOOLS_GN_TOKENIZER_H_
+
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/strings/string_piece.h"
+#include "tools/gn/err.h"
+#include "tools/gn/token.h"
+
+class InputFile;
+
+class Tokenizer {
+ public:
+ static std::vector<Token> Tokenize(const InputFile* input_file, Err* err);
+
+ // Counts lines in the given buffer (the first line is "1") and returns
+ // the byte offset of the beginning of that line, or (size_t)-1 if there
+ // aren't that many lines in the file. Note that this will return the byte
+ // one past the end of the input if the last character is a newline.
+ //
+ // This is a helper function for error output so that the tokenizer's
+ // notion of lines can be used elsewhere.
+ static size_t ByteOffsetOfNthLine(const base::StringPiece& buf, int n);
+
+ // Returns true if the given offset of the string piece counts as a newline.
+ // The offset must be in the buffer.
+ static bool IsNewline(const base::StringPiece& buffer, size_t offset);
+
+ static bool IsIdentifierFirstChar(char c) {
+ return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == '_';
+ }
+
+ static bool IsIdentifierContinuingChar(char c) {
+ // Also allow digits after the first char.
+ return IsIdentifierFirstChar(c) || (c >= '0' && c <= '9');
+ }
+
+ private:
+ // InputFile must outlive the tokenizer and all generated tokens.
+ explicit Tokenizer(const InputFile* input_file, Err* err);
+ ~Tokenizer();
+
+ std::vector<Token> Run();
+
+ void AdvanceToNextToken();
+ Token::Type ClassifyCurrent() const;
+ void AdvanceToEndOfToken(const Location& location, Token::Type type);
+
+ bool IsCurrentWhitespace() const;
+ bool IsCurrentNewline() const;
+ bool IsCurrentStringTerminator(char quote_char) const;
+
+ bool CanIncrement() const { return cur_ < input_.size(); }
+
+ // Increments the current location by one.
+ void Advance();
+
+ // Returns the current character in the file as a location.
+ Location GetCurrentLocation() const;
+
+ Err GetErrorForInvalidToken(const Location& location) const;
+
+ bool done() const { return at_end() || has_error(); }
+
+ bool at_end() const { return cur_ == input_.size(); }
+ char cur_char() const { return input_[cur_]; }
+
+ bool has_error() const { return err_->has_error(); }
+
+ const InputFile* input_file_;
+ const base::StringPiece input_;
+ Err* err_;
+ size_t cur_; // Byte offset into input buffer.
+
+ int line_number_;
+ int char_in_line_;
+
+ DISALLOW_COPY_AND_ASSIGN(Tokenizer);
+};
+
+#endif // TOOLS_GN_TOKENIZER_H_
diff --git a/tools/gn/tokenizer_unittest.cc b/tools/gn/tokenizer_unittest.cc
new file mode 100644
index 0000000..d1a6788
--- /dev/null
+++ b/tools/gn/tokenizer_unittest.cc
@@ -0,0 +1,162 @@
+// 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/input_file.h"
+#include "tools/gn/token.h"
+#include "tools/gn/tokenizer.h"
+
+namespace {
+
+struct TokenExpectation {
+ Token::Type type;
+ const char* value;
+};
+
+template<size_t len>
+bool CheckTokenizer(const char* input, const TokenExpectation (&expect)[len]) {
+ InputFile input_file(SourceFile("/test"));
+ input_file.SetContents(input);
+
+ Err err;
+ std::vector<Token> results = Tokenizer::Tokenize(&input_file, &err);
+
+ if (results.size() != len)
+ return false;
+ for (size_t i = 0; i < len; i++) {
+ if (expect[i].type != results[i].type())
+ return false;
+ if (expect[i].value != results[i].value())
+ return false;
+ }
+ return true;
+}
+
+} // namespace
+
+TEST(Tokenizer, Empty) {
+ InputFile empty_string_input(SourceFile("/test"));
+ empty_string_input.SetContents("");
+
+ Err err;
+ std::vector<Token> results = Tokenizer::Tokenize(&empty_string_input, &err);
+ EXPECT_TRUE(results.empty());
+
+ InputFile whitespace_input(SourceFile("/test"));
+ whitespace_input.SetContents(" \n\r");
+
+ results = Tokenizer::Tokenize(&whitespace_input, &err);
+ EXPECT_TRUE(results.empty());
+}
+
+TEST(Tokenizer, Identifier) {
+ TokenExpectation one_ident[] = {
+ { Token::IDENTIFIER, "foo" }
+ };
+ EXPECT_TRUE(CheckTokenizer(" foo ", one_ident));
+}
+
+TEST(Tokenizer, Integer) {
+ TokenExpectation integers[] = {
+ { Token::INTEGER, "123" },
+ { Token::INTEGER, "-123" }
+ };
+ EXPECT_TRUE(CheckTokenizer(" 123 -123 ", integers));
+}
+
+TEST(Tokenizer, String) {
+ TokenExpectation strings[] = {
+ { Token::STRING, "\"foo\"" },
+ { Token::STRING, "\"bar\\\"baz\"" },
+ { Token::STRING, "\"asdf\\\\\"" }
+ };
+ EXPECT_TRUE(CheckTokenizer(" \"foo\" \"bar\\\"baz\" \"asdf\\\\\" ",
+ strings));
+}
+
+TEST(Tokenizer, Operator) {
+ TokenExpectation operators[] = {
+ { Token::OPERATOR, "-" },
+ { Token::OPERATOR, "+" },
+ { Token::OPERATOR, "=" },
+ { Token::OPERATOR, "+=" },
+ { Token::OPERATOR, "-=" },
+ { Token::OPERATOR, "!=" },
+ { Token::OPERATOR, "==" },
+ { Token::OPERATOR, "<" },
+ { Token::OPERATOR, ">" },
+ { Token::OPERATOR, "<=" },
+ { Token::OPERATOR, ">=" },
+ };
+ EXPECT_TRUE(CheckTokenizer("- + = += -= != == < > <= >=",
+ operators));
+}
+
+TEST(Tokenizer, Scoper) {
+ TokenExpectation scopers[] = {
+ { Token::SCOPER, "{" },
+ { Token::SCOPER, "[" },
+ { Token::SCOPER, "]" },
+ { Token::SCOPER, "}" },
+ { Token::SCOPER, "(" },
+ { Token::SCOPER, ")" },
+ };
+ EXPECT_TRUE(CheckTokenizer("{[ ]} ()", scopers));
+}
+
+TEST(Tokenizer, FunctionCall) {
+ TokenExpectation fn[] = {
+ { Token::IDENTIFIER, "fun" },
+ { Token::SCOPER, "(" },
+ { Token::STRING, "\"foo\"" },
+ { Token::SCOPER, ")" },
+ { Token::SCOPER, "{" },
+ { Token::IDENTIFIER, "foo" },
+ { Token::OPERATOR, "=" },
+ { Token::INTEGER, "12" },
+ { Token::SCOPER, "}" },
+ };
+ EXPECT_TRUE(CheckTokenizer("fun(\"foo\") {\nfoo = 12}", fn));
+}
+
+TEST(Tokenizer, StringUnescaping) {
+ InputFile input(SourceFile("/test"));
+ input.SetContents("\"asd\\\"f\" \"\"");
+ Err err;
+ std::vector<Token> results = Tokenizer::Tokenize(&input, &err);
+
+ ASSERT_EQ(2u, results.size());
+ EXPECT_EQ("asd\"f", results[0].StringValue());
+ EXPECT_EQ("", results[1].StringValue());
+}
+
+TEST(Tokenizer, Locations) {
+ InputFile input(SourceFile("/test"));
+ input.SetContents("1 2 \"three\"\n 4");
+ Err err;
+ std::vector<Token> results = Tokenizer::Tokenize(&input, &err);
+
+ ASSERT_EQ(4u, results.size());
+ ASSERT_TRUE(results[0].location() == Location(&input, 1, 1));
+ ASSERT_TRUE(results[1].location() == Location(&input, 1, 3));
+ ASSERT_TRUE(results[2].location() == Location(&input, 1, 5));
+ ASSERT_TRUE(results[3].location() == Location(&input, 2, 3));
+}
+
+TEST(Tokenizer, ByteOffsetOfNthLine) {
+ EXPECT_EQ(0u, Tokenizer::ByteOffsetOfNthLine("foo", 1));
+
+ // Windows and Posix have different line endings, so check the byte at the
+ // location rather than the offset.
+ char input1[] = "aaa\nxaa\n\nya";
+ EXPECT_EQ('x', input1[Tokenizer::ByteOffsetOfNthLine(input1, 2)]);
+ EXPECT_EQ('y', input1[Tokenizer::ByteOffsetOfNthLine(input1, 4)]);
+
+ char input2[3];
+ input2[0] = 'a';
+ input2[1] = '\n'; // Manually set to avoid Windows double-byte endings.
+ input2[2] = 0;
+ EXPECT_EQ(0u, Tokenizer::ByteOffsetOfNthLine(input2, 1));
+ EXPECT_EQ(2u, Tokenizer::ByteOffsetOfNthLine(input2, 2));
+}
diff --git a/tools/gn/toolchain.cc b/tools/gn/toolchain.cc
new file mode 100644
index 0000000..20b81f5
--- /dev/null
+++ b/tools/gn/toolchain.cc
@@ -0,0 +1,79 @@
+// 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/toolchain.h"
+
+#include "base/logging.h"
+
+const char* Toolchain::kToolCc = "cc";
+const char* Toolchain::kToolCxx = "cxx";
+const char* Toolchain::kToolAsm = "asm";
+const char* Toolchain::kToolAlink = "alink";
+const char* Toolchain::kToolSolink = "solink";
+const char* Toolchain::kToolSolinkModule = "solink_module";
+const char* Toolchain::kToolLink = "link";
+const char* Toolchain::kToolStamp = "stamp";
+const char* Toolchain::kToolCopy = "copy";
+
+Toolchain::Tool::Tool() {
+}
+
+Toolchain::Tool::~Tool() {
+}
+
+Toolchain::Toolchain(const Label& label) : Item(label) {
+}
+
+Toolchain::~Toolchain() {
+}
+
+Toolchain* Toolchain::AsToolchain() {
+ return this;
+}
+
+const Toolchain* Toolchain::AsToolchain() const {
+ return this;
+}
+
+// static
+Toolchain::ToolType Toolchain::ToolNameToType(const base::StringPiece& str) {
+ if (str == kToolCc) return TYPE_CC;
+ if (str == kToolCxx) return TYPE_CXX;
+ if (str == kToolAsm) return TYPE_ASM;
+ if (str == kToolAlink) return TYPE_ALINK;
+ if (str == kToolSolink) return TYPE_SOLINK;
+ if (str == kToolSolinkModule) return TYPE_SOLINK_MODULE;
+ if (str == kToolLink) return TYPE_LINK;
+ if (str == kToolStamp) return TYPE_STAMP;
+ if (str == kToolCopy) return TYPE_COPY;
+ return TYPE_NONE;
+}
+
+// static
+std::string Toolchain::ToolTypeToName(ToolType type) {
+ switch (type) {
+ case TYPE_CC: return kToolCc;
+ case TYPE_CXX: return kToolCxx;
+ case TYPE_ASM: return kToolAsm;
+ case TYPE_ALINK: return kToolAlink;
+ case TYPE_SOLINK: return kToolSolink;
+ case TYPE_SOLINK_MODULE: return kToolSolinkModule;
+ case TYPE_LINK: return kToolLink;
+ case TYPE_STAMP: return kToolStamp;
+ case TYPE_COPY: return kToolCopy;
+ default:
+ NOTREACHED();
+ return std::string();
+ }
+}
+
+const Toolchain::Tool& Toolchain::GetTool(ToolType type) const {
+ DCHECK(type != TYPE_NONE);
+ return tools_[static_cast<size_t>(type)];
+}
+
+void Toolchain::SetTool(ToolType type, const Tool& t) {
+ DCHECK(type != TYPE_NONE);
+ tools_[static_cast<size_t>(type)] = t;
+}
diff --git a/tools/gn/toolchain.h b/tools/gn/toolchain.h
new file mode 100644
index 0000000..22b8151
--- /dev/null
+++ b/tools/gn/toolchain.h
@@ -0,0 +1,94 @@
+// 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_TOOLCHAIN_H_
+#define TOOLS_GN_TOOLCHAIN_H_
+
+#include "base/compiler_specific.h"
+#include "base/strings/string_piece.h"
+#include "tools/gn/item.h"
+
+// Holds information on a specific toolchain. This data is filled in when we
+// encounter a toolchain definition.
+//
+// This class is an Item so it can participate in dependency management. In
+// particular, when a target uses a toolchain, it should have a dependency on
+// that toolchain's object so that we can be sure we loaded the toolchain
+// before generating the build for that target.
+//
+// Note on threadsafety: The label of the toolchain never changes so can
+// safetly be accessed from any thread at any time (we do this when asking for
+// the toolchain name). But the values in the toolchain do, so these can't
+// be accessed until this Item is resolved.
+class Toolchain : public Item {
+ public:
+ enum ToolType {
+ TYPE_NONE = 0,
+ TYPE_CC,
+ TYPE_CXX,
+ TYPE_ASM,
+ TYPE_ALINK,
+ TYPE_SOLINK,
+ TYPE_SOLINK_MODULE,
+ TYPE_LINK,
+ TYPE_STAMP,
+ TYPE_COPY,
+
+ TYPE_NUMTYPES // Must be last.
+ };
+
+ static const char* kToolCc;
+ static const char* kToolCxx;
+ static const char* kToolAsm;
+ static const char* kToolAlink;
+ static const char* kToolSolink;
+ static const char* kToolSolinkModule;
+ static const char* kToolLink;
+ static const char* kToolStamp;
+ static const char* kToolCopy;
+
+ struct Tool {
+ Tool();
+ ~Tool();
+
+ bool empty() const {
+ return command.empty() && depfile.empty() && deps.empty() &&
+ description.empty() && pool.empty() && restat.empty() &&
+ rspfile.empty() && rspfile_content.empty();
+ }
+
+ std::string command;
+ std::string depfile;
+ std::string deps;
+ std::string description;
+ std::string pool;
+ std::string restat;
+ std::string rspfile;
+ std::string rspfile_content;
+ };
+
+ Toolchain(const Label& label);
+ virtual ~Toolchain();
+
+ // Item overrides.
+ virtual Toolchain* AsToolchain() OVERRIDE;
+ virtual const Toolchain* AsToolchain() const OVERRIDE;
+
+ // Returns TYPE_NONE on failure.
+ static ToolType ToolNameToType(const base::StringPiece& str);
+ static std::string ToolTypeToName(ToolType type);
+
+ const Tool& GetTool(ToolType type) const;
+ void SetTool(ToolType type, const Tool& t);
+
+ const std::string& environment() const { return environment_; }
+ void set_environment(const std::string& env) { environment_ = env; }
+
+ private:
+ Tool tools_[TYPE_NUMTYPES];
+
+ std::string environment_;
+};
+
+#endif // TOOLS_GN_TOOLCHAIN_H_
diff --git a/tools/gn/toolchain_manager.cc b/tools/gn/toolchain_manager.cc
new file mode 100644
index 0000000..8a54163
--- /dev/null
+++ b/tools/gn/toolchain_manager.cc
@@ -0,0 +1,480 @@
+// 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/toolchain_manager.h"
+
+#include <set>
+
+#include "base/bind.h"
+#include "tools/gn/err.h"
+#include "tools/gn/item.h"
+#include "tools/gn/item_node.h"
+#include "tools/gn/item_tree.h"
+#include "tools/gn/parse_tree.h"
+#include "tools/gn/scheduler.h"
+#include "tools/gn/scope.h"
+#include "tools/gn/scope_per_file_provider.h"
+
+namespace {
+
+SourceFile DirToBuildFile(const SourceDir& dir) {
+ return SourceFile(dir.value() + "BUILD.gn");
+}
+
+void SetSystemVars(const Settings& settings, Scope* scope) {
+ // FIXME(brettw) port.
+ scope->SetValue("is_win", Value(NULL, 1), NULL);
+ scope->SetValue("is_linux", Value(NULL, 0), NULL);
+ scope->SetValue("is_posix", Value(NULL, 0), NULL);
+ scope->SetValue("is_mac", Value(NULL, 0), NULL);
+ scope->SetValue("is_android", Value(NULL, 0), NULL);
+ scope->SetValue("is_ios", Value(NULL, 0), NULL);
+
+ // Set this value without the terminating slash because the code expects
+ // $root_output_dir/foo to work.
+ scope->SetValue(ScopePerFileProvider::kRootOutputDirName,
+ ScopePerFileProvider::GetRootOutputDir(&settings),
+ NULL);
+ scope->SetValue(ScopePerFileProvider::kRootGenDirName,
+ ScopePerFileProvider::GetRootGenDir(&settings),
+ NULL);
+}
+
+} // namespace
+
+struct ToolchainManager::Info {
+ Info(const BuildSettings* build_settings,
+ const Label& toolchain_name,
+ const std::string& output_subdir_name)
+ : state(TOOLCHAIN_SETTINGS_NOT_LOADED),
+ toolchain(toolchain_name),
+ toolchain_set(false),
+ settings(build_settings, &toolchain, output_subdir_name),
+ item_node(NULL) {
+ }
+
+ // MAkes sure that an ItemNode is created for the toolchain, which lets
+ // targets depend on the (potentially future) loading of the toolchain.
+ //
+ // We can't always do this at the beginning since when doing the default
+ // build config, we don't know the toolchain name yet. We also need to go
+ // through some effort to avoid doing this inside the toolchain manager's
+ // lock (to avoid holding two locks at once).
+ void EnsureItemNode() {
+ if (!item_node) {
+ ItemTree& tree = settings.build_settings()->item_tree();
+ item_node = new ItemNode(&toolchain);
+ tree.AddNodeLocked(item_node);
+ }
+ }
+
+ SettingsState state;
+
+ Toolchain toolchain;
+ bool toolchain_set;
+ LocationRange toolchain_definition_location;
+
+ // When the state is TOOLCHAIN_SETTINGS_LOADED, the settings should be
+ // considered read-only and can be read without locking. Otherwise, they
+ // should not be accessed at all except to load them (which can therefore
+ // also be done outside of the lock). This works as long as the state flag
+ // is only ever read or written inside the lock.
+ Settings settings;
+
+ // While state == TOOLCHAIN_SETTINGS_LOADING, this will collect all
+ // scheduled invocations using this toolchain. They'll be issued once the
+ // settings file has been interpreted.
+ //
+ // The map maps the source file to "some" location it was invoked from (so
+ // we can give good error messages. It does NOT map to the root of the
+ // file to be invoked (the file still needs loading). This will be NULL
+ // for internally invoked files.
+ typedef std::map<SourceFile, LocationRange> ScheduledInvocationMap;
+ ScheduledInvocationMap scheduled_invocations;
+
+ // Tracks all scheduled and executed invocations for this toolchain. This
+ // is used to avoid invoking a file more than once for a toolchain.
+ std::set<SourceFile> all_invocations;
+
+ // Filled in by EnsureItemNode, see that for more.
+ ItemNode* item_node;
+};
+
+ToolchainManager::ToolchainManager(const BuildSettings* build_settings)
+ : build_settings_(build_settings) {
+}
+
+ToolchainManager::~ToolchainManager() {
+ for (ToolchainMap::iterator i = toolchains_.begin();
+ i != toolchains_.end(); ++i)
+ delete i->second;
+ toolchains_.clear();
+}
+
+void ToolchainManager::StartLoadingUnlocked(const SourceFile& build_file_name) {
+ // How the default build config works: Initially we don't have a toolchain
+ // name to call the settings for the default build config. So we create one
+ // with an empty toolchain name and execute the default build config file.
+ // When that's done, we'll go and fix up the name to the default build config
+ // that the script set.
+ base::AutoLock lock(GetLock());
+ Err err;
+ Info* info = LoadNewToolchainLocked(LocationRange(), Label(), &err);
+ if (err.has_error())
+ g_scheduler->FailWithError(err);
+ CHECK(info);
+ info->scheduled_invocations[build_file_name] = LocationRange();
+ info->all_invocations.insert(build_file_name);
+
+ g_scheduler->IncrementWorkCount();
+ if (!g_scheduler->input_file_manager()->AsyncLoadFile(
+ LocationRange(), build_settings_,
+ build_settings_->build_config_file(),
+ base::Bind(&ToolchainManager::BackgroundLoadBuildConfig,
+ base::Unretained(this), info, true),
+ &err)) {
+ g_scheduler->FailWithError(err);
+ g_scheduler->DecrementWorkCount();
+ }
+}
+
+const Settings* ToolchainManager::GetSettingsForToolchainLocked(
+ const LocationRange& from_here,
+ const Label& toolchain_name,
+ Err* err) {
+ GetLock().AssertAcquired();
+ ToolchainMap::iterator found = toolchains_.find(toolchain_name);
+ Info* info = NULL;
+ if (found == toolchains_.end()) {
+ info = LoadNewToolchainLocked(from_here, toolchain_name, err);
+ if (!info)
+ return NULL;
+ } else {
+ info = found->second;
+ }
+ info->EnsureItemNode();
+
+ return &info->settings;
+}
+
+const Toolchain* ToolchainManager::GetToolchainDefinitionUnlocked(
+ const Label& toolchain_name) {
+ base::AutoLock lock(GetLock());
+ ToolchainMap::iterator found = toolchains_.find(toolchain_name);
+ if (found == toolchains_.end() || !found->second->toolchain_set)
+ return NULL;
+
+ // Since we don't allow defining a toolchain more than once, we know that
+ // once it's set it won't be mutated, so we can safely return this pointer
+ // for reading outside the lock.
+ return &found->second->toolchain;
+}
+
+bool ToolchainManager::SetDefaultToolchainUnlocked(
+ const Label& default_toolchain,
+ const LocationRange& defined_here,
+ Err* err) {
+ base::AutoLock lock(GetLock());
+ if (!default_toolchain_.is_null()) {
+ *err = Err(defined_here, "Default toolchain already set.");
+ err->AppendSubErr(Err(default_toolchain_defined_here_,
+ "Previously defined here.",
+ "You can only set this once."));
+ return false;
+ }
+
+ if (default_toolchain.is_null()) {
+ *err = Err(defined_here, "Bad default toolchain name.",
+ "You can't set the default toolchain name to nothing.");
+ return false;
+ }
+ if (!default_toolchain.toolchain_dir().is_null() ||
+ !default_toolchain.toolchain_name().empty()) {
+ *err = Err(defined_here, "Toolchain name has toolchain.",
+ "You can't specify a toolchain (inside the parens) for a toolchain "
+ "name. I got:\n" + default_toolchain.GetUserVisibleName(true));
+ return false;
+ }
+
+ default_toolchain_ = default_toolchain;
+ default_toolchain_defined_here_ = defined_here;
+ return true;
+}
+
+Label ToolchainManager::GetDefaultToolchainUnlocked() const {
+ base::AutoLock lock(GetLock());
+ return default_toolchain_;
+}
+
+bool ToolchainManager::SetToolchainDefinitionLocked(
+ const Toolchain& tc,
+ const LocationRange& defined_from,
+ Err* err) {
+ GetLock().AssertAcquired();
+
+ ToolchainMap::iterator found = toolchains_.find(tc.label());
+ Info* info = NULL;
+ if (found == toolchains_.end()) {
+ // New toolchain.
+ info = LoadNewToolchainLocked(defined_from, tc.label(), err);
+ if (!info)
+ return false;
+ } else {
+ // It's important to preserve the exact Toolchain object in our tree since
+ // it will be in the ItemTree and targets may have dependencies on it.
+ info = found->second;
+ }
+
+ // The labels should match or else we're setting the wrong one!
+ CHECK(info->toolchain.label() == tc.label());
+
+ info->toolchain = tc;
+ if (info->toolchain_set) {
+ *err = Err(defined_from, "Duplicate toolchain definition.");
+ err->AppendSubErr(Err(
+ info->toolchain_definition_location,
+ "Previously defined here.",
+ "A toolchain can only be defined once. One tricky way that this could\n"
+ "happen is if your definition is itself in a file that's interpreted\n"
+ "under different toolchains, which would result in multiple\n"
+ "definitions as the file is loaded multiple times. So be sure your\n"
+ "toolchain definitions are in files that either don't define any\n"
+ "targets (probably best) or at least don't contain targets executed\n"
+ "with more than one toolchain."));
+ return false;
+ }
+
+ info->EnsureItemNode();
+
+ info->toolchain_set = true;
+ info->toolchain_definition_location = defined_from;
+ return true;
+}
+
+bool ToolchainManager::ScheduleInvocationLocked(
+ const LocationRange& specified_from,
+ const Label& toolchain_name,
+ const SourceDir& dir,
+ Err* err) {
+ GetLock().AssertAcquired();
+ SourceFile build_file(DirToBuildFile(dir));
+
+ ToolchainMap::iterator found = toolchains_.find(toolchain_name);
+ Info* info = NULL;
+ if (found == toolchains_.end()) {
+ // New toolchain.
+ info = LoadNewToolchainLocked(specified_from, toolchain_name, err);
+ if (!info)
+ return false;
+ } else {
+ // Use existing one.
+ info = found->second;
+ if (info->all_invocations.find(build_file) !=
+ info->all_invocations.end()) {
+ // We've already seen this source file for this toolchain, don't need
+ // to do anything.
+ return true;
+ }
+ }
+
+ info->all_invocations.insert(build_file);
+
+ // True if the settings load needs to be scheduled.
+ bool info_needs_settings_load = false;
+
+ // True if the settings load has completed.
+ bool info_settings_loaded = false;
+
+ switch (info->state) {
+ case TOOLCHAIN_SETTINGS_NOT_LOADED:
+ info_needs_settings_load = true;
+ info->scheduled_invocations[build_file] = specified_from;
+ break;
+
+ case TOOLCHAIN_SETTINGS_LOADING:
+ info->scheduled_invocations[build_file] = specified_from;
+ break;
+
+ case TOOLCHAIN_SETTINGS_LOADED:
+ info_settings_loaded = true;
+ break;
+ }
+
+ if (info_needs_settings_load) {
+ // Load the settings file.
+ g_scheduler->IncrementWorkCount();
+ if (!g_scheduler->input_file_manager()->AsyncLoadFile(
+ specified_from, build_settings_,
+ build_settings_->build_config_file(),
+ base::Bind(&ToolchainManager::BackgroundLoadBuildConfig,
+ base::Unretained(this), info, false),
+ err)) {
+ g_scheduler->DecrementWorkCount();
+ return false;
+ }
+ } else if (info_settings_loaded) {
+ // Settings are ready to go, load the target file.
+ g_scheduler->IncrementWorkCount();
+ if (!g_scheduler->input_file_manager()->AsyncLoadFile(
+ specified_from, build_settings_, build_file,
+ base::Bind(&ToolchainManager::BackgroundInvoke,
+ base::Unretained(this), info, build_file),
+ err)) {
+ g_scheduler->DecrementWorkCount();
+ return false;
+ }
+ }
+ // Else we should have added the infocations to the scheduled_invocations
+ // from within the lock above.
+ return true;
+}
+
+// static
+std::string ToolchainManager::ToolchainToOutputSubdir(
+ const Label& toolchain_name) {
+ // For now just assume the toolchain name is always a valid dir name. We may
+ // want to clean up the in the future.
+ return toolchain_name.name();
+}
+
+ToolchainManager::Info* ToolchainManager::LoadNewToolchainLocked(
+ const LocationRange& specified_from,
+ const Label& toolchain_name,
+ Err* err) {
+ GetLock().AssertAcquired();
+ Info* info = new Info(build_settings_,
+ toolchain_name,
+ ToolchainToOutputSubdir(toolchain_name));
+
+ toolchains_[toolchain_name] = info;
+
+ // Invoke the file containing the toolchain definition so that it gets
+ // defined. The default one (label is empty) will be done spearately.
+ if (!toolchain_name.is_null()) {
+ // The default toolchain should be specified whenever we're requesting
+ // another one. This is how we know under what context we should execute
+ // the invoke for the toolchain file.
+ CHECK(!default_toolchain_.is_null());
+ ScheduleInvocationLocked(specified_from, default_toolchain_,
+ toolchain_name.dir(), err);
+ }
+ return info;
+}
+
+void ToolchainManager::FixupDefaultToolchainLocked() {
+ // Now that we've run the default build config, we should know the
+ // default toolchain name. Fix up our reference.
+ // See Start() for more.
+ GetLock().AssertAcquired();
+ if (default_toolchain_.is_null()) {
+ g_scheduler->FailWithError(Err(Location(),
+ "Default toolchain not set.",
+ "Your build config file \"" +
+ build_settings_->build_config_file().value() +
+ "\"\ndid not call set_default_toolchain(). This is needed so "
+ "I know how to actually\ncompile your code."));
+ return;
+ }
+
+ ToolchainMap::iterator old_default = toolchains_.find(Label());
+ CHECK(old_default != toolchains_.end());
+ Info* info = old_default->second;
+ toolchains_[default_toolchain_] = info;
+ toolchains_.erase(old_default);
+
+ // Toolchain should not have been loaded in the build config file.
+ CHECK(!info->toolchain_set);
+
+ // We need to set the toolchain label now that we know it. There's no way
+ // to set the label, but we can assign the toolchain to a new one. Loading
+ // the build config can not change the toolchain, so we won't be overwriting
+ // anything useful.
+ info->toolchain = Toolchain(default_toolchain_);
+ info->EnsureItemNode();
+
+ // Schedule a load of the toolchain build file.
+ Err err;
+ ScheduleInvocationLocked(LocationRange(), default_toolchain_,
+ default_toolchain_.dir(), &err);
+ if (err.has_error())
+ g_scheduler->FailWithError(err);
+}
+
+void ToolchainManager::BackgroundLoadBuildConfig(Info* info,
+ bool is_default,
+ const ParseNode* root) {
+ // Danger: No early returns without decrementing the work count.
+ if (root && !g_scheduler->is_failed()) {
+ // Nobody should be accessing settings at this point other than us since we
+ // haven't marked it loaded, so we can do it outside the lock.
+ Scope* base_config = info->settings.base_config();
+ SetSystemVars(info->settings, base_config);
+ base_config->SetProcessingBuildConfig();
+ if (is_default)
+ base_config->SetProcessingDefaultBuildConfig();
+
+ const BlockNode* root_block = root->AsBlock();
+ Err err;
+ root_block->ExecuteBlockInScope(base_config, &err);
+
+ base_config->ClearProcessingBuildConfig();
+ if (is_default)
+ base_config->ClearProcessingDefaultBuildConfig();
+
+ if (err.has_error()) {
+ g_scheduler->FailWithError(err);
+ } else {
+ // Base config processing succeeded.
+ Info::ScheduledInvocationMap schedule_these;
+ {
+ base::AutoLock lock(GetLock());
+ schedule_these.swap(info->scheduled_invocations);
+ info->state = TOOLCHAIN_SETTINGS_LOADED;
+ if (is_default)
+ FixupDefaultToolchainLocked();
+ }
+
+ // Schedule build files waiting on this settings. There can be many so we
+ // want to load them in parallel on the pool.
+ for (Info::ScheduledInvocationMap::iterator i = schedule_these.begin();
+ i != schedule_these.end() && !g_scheduler->is_failed(); ++i) {
+ // Note i->second may be NULL, so don't dereference.
+ g_scheduler->IncrementWorkCount();
+ if (!g_scheduler->input_file_manager()->AsyncLoadFile(
+ i->second, build_settings_, i->first,
+ base::Bind(&ToolchainManager::BackgroundInvoke,
+ base::Unretained(this), info, i->first),
+ &err)) {
+ g_scheduler->FailWithError(err);
+ g_scheduler->DecrementWorkCount();
+ break;
+ }
+ }
+ }
+ }
+ g_scheduler->DecrementWorkCount();
+}
+
+void ToolchainManager::BackgroundInvoke(const Info* info,
+ const SourceFile& file_name,
+ const ParseNode* root) {
+ if (root && !g_scheduler->is_failed()) {
+ if (g_scheduler->verbose_logging())
+ g_scheduler->Log("Running", file_name.value());
+
+ Scope our_scope(info->settings.base_config());
+ ScopePerFileProvider per_file_provider(&our_scope, file_name);
+
+ Err err;
+ root->Execute(&our_scope, &err);
+ if (err.has_error())
+ g_scheduler->FailWithError(err);
+ }
+
+ g_scheduler->DecrementWorkCount();
+}
+
+base::Lock& ToolchainManager::GetLock() const {
+ return build_settings_->item_tree().lock();
+}
diff --git a/tools/gn/toolchain_manager.h b/tools/gn/toolchain_manager.h
new file mode 100644
index 0000000..4c0be41
--- /dev/null
+++ b/tools/gn/toolchain_manager.h
@@ -0,0 +1,167 @@
+// 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_TOOLCHAIN_MANAGER_H_
+#define TOOLS_GN_TOOLCHAIN_MANAGER_H_
+
+#include <map>
+
+#include "base/basictypes.h"
+#include "base/synchronization/lock.h"
+#include "tools/gn/label.h"
+#include "tools/gn/location.h"
+#include "tools/gn/source_file.h"
+#include "tools/gn/toolchain.h"
+
+class Err;
+class BuildSettings;
+class ParseNode;
+class Settings;
+
+// The toolchain manager manages the mapping of toolchain names to the
+// settings and toolchain object. It also loads build files in the context of a
+// toolchain context of a toolchain, and manages running the build config
+// script when necessary.
+//
+// This class uses the lock from the item tree to manage threadsafety. The
+// functions requiring this lock to be held are named "Locked" to make this
+// more clear. The "Unlocked" versions will acquire the lock themselves so will
+// break if you call it while locked. (The rationale behind which is which is
+// just based on the needs of the callers, so it can be changed.) There are two
+// reasons for this:
+//
+// The first is that when resolving a target, we do a bunch of script
+// stuff (slow) and then lookup the target, config, and toolchain dependencies
+// based on that. The options are to do a lock around each dependency lookup
+// or do a lock around the entire operation. Given that there's not a huge
+// amount of work, the "big lock" approach is likely a bit better since it
+// avoids lots of locking overhead.
+//
+// The second reason is that if we had a separate lock here, we would need to
+// lock around creating a new toolchain. But creating a new toolchain involves
+// adding it to the item tree, and this needs to be done atomically to prevent
+// other threads from seeing a partially initialized toolchain. This sets up
+// having deadlock do to acquiring multiple locks, or recursive locking
+// problems.
+class ToolchainManager {
+ public:
+ ToolchainManager(const BuildSettings* build_settings);
+ ~ToolchainManager();
+
+ // At the very beginning of processing, this begins loading build files.
+ // This will scheduler loadin the default build config and the given build
+ // file in that context, going out from there.
+ //
+ // This returns immediately, you need to run the Scheduler to actually
+ // process anything. It's assumed this function is called on the main thread
+ // before doing anything, so it does not need locking.
+ void StartLoadingUnlocked(const SourceFile& build_file_name);
+
+ // Returns the settings object for a given toolchain. This does not
+ // schedule loading the given toolchain if it's not loaded yet: you actually
+ // need to invoke a target with that toolchain to get that.
+ //
+ // On error, returns NULL and sets the error.
+ const Settings* GetSettingsForToolchainLocked(const LocationRange& from_here,
+ const Label& toolchain_name,
+ Err* err);
+
+ // Returns the toolchain definition or NULL if the toolchain hasn't been
+ // defined yet.
+ const Toolchain* GetToolchainDefinitionUnlocked(const Label& toolchain_name);
+
+ // Sets the default toolchain. If the default toolchain is already set,
+ // this function will return false and fill in the given err.
+ bool SetDefaultToolchainUnlocked(const Label& dt,
+ const LocationRange& defined_from,
+ Err* err);
+
+ // Returns the default toolchain name. This will be empty if it hasn't been
+ // set.
+ Label GetDefaultToolchainUnlocked() const;
+
+ // Saves the given named toolchain (the name will be taken from the toolchain
+ // parameter). This will fail and return false if the given toolchain was
+ // already defined. In this case, the given error will be set.
+ bool SetToolchainDefinitionLocked(const Toolchain& tc,
+ const LocationRange& defined_from,
+ Err* err);
+
+ // Schedules an invocation of the given file under the given toolchain. The
+ // toolchain file will be loaded if necessary.
+ //
+ // The origin should be the node that will be blamed for this invocation if
+ // an error occurs. If a synchronous error occurs, the given error will be
+ // set and it will return false. If an async error occurs, the error will be
+ // sent to the scheduler.
+ bool ScheduleInvocationLocked(const LocationRange& origin,
+ const Label& toolchain_name,
+ const SourceDir& dir,
+ Err* err);
+
+ private:
+ enum SettingsState {
+ // Toolchain settings have not requested to be loaded. This means we
+ // haven't seen any targets that require this toolchain yet. Not loading
+ // the settings automatically allows you to define a bunch of toolchains
+ // and potentially not use them without much overhead.
+ TOOLCHAIN_SETTINGS_NOT_LOADED,
+
+ // The settings have been scheduled to be loaded but have not completed.
+ TOOLCHAIN_SETTINGS_LOADING,
+
+ // The settings are done being loaded.
+ TOOLCHAIN_SETTINGS_LOADED
+ };
+
+ struct Info;
+
+ static std::string ToolchainToOutputSubdir(const Label& toolchain_name);
+
+ // Creates a new info struct and saves it in the map. A pointer to the
+ // struct is returned. No loads are scheduled.
+ //
+ // If the label is non-empty, the toolchain will be added to the ItemTree
+ // so that other nodes can depend on it. THe empty label case is for the
+ // default build config file (when the toolchain name isn't known yet). It
+ // will be added later.
+ //
+ // On error, will return NULL and the error will be set.
+ Info* LoadNewToolchainLocked(const LocationRange& specified_from,
+ const Label& toolchain_name,
+ Err* err);
+
+ // Fixes up the default toolchain names once they're known when processing
+ // the default build config, or throw an error if the default toolchain
+ // hasn't been set. See the StartLoading() implementation for more.
+ void FixupDefaultToolchainLocked();
+
+ // Loads the base config for the given toolchain. Run on a background thread
+ // asynchronously.
+ void BackgroundLoadBuildConfig(Info* info,
+ bool is_default,
+ const ParseNode* root);
+
+ // Invokes the given file for a toolchain with loaded settings. Run on a
+ // background thread asynchronously.
+ void BackgroundInvoke(const Info* info,
+ const SourceFile& file_name,
+ const ParseNode* root);
+
+ // Returns the lock to use.
+ base::Lock& GetLock() const;
+
+ const BuildSettings* build_settings_;
+
+ // We own the info pointers.
+ typedef std::map<Label, Info*> ToolchainMap;
+ ToolchainMap toolchains_;
+
+ Label default_toolchain_;
+ LocationRange default_toolchain_defined_here_;
+
+ DISALLOW_COPY_AND_ASSIGN(ToolchainManager);
+};
+
+#endif // TOOLS_GN_TOOLCHAIN_MANAGER_H_
diff --git a/tools/gn/value.cc b/tools/gn/value.cc
new file mode 100644
index 0000000..cb78faa
--- /dev/null
+++ b/tools/gn/value.cc
@@ -0,0 +1,126 @@
+// 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/value.h"
+
+#include "base/strings/string_number_conversions.h"
+
+Value::Value()
+ : type_(NONE),
+ int_value_(0),
+ origin_(NULL) {
+}
+
+Value::Value(const ParseNode* origin, Type t)
+ : type_(t),
+ int_value_(0),
+ origin_(origin) {
+}
+
+Value::Value(const ParseNode* origin, int64 int_val)
+ : type_(INTEGER),
+ int_value_(int_val),
+ origin_(origin) {
+}
+
+Value::Value(const ParseNode* origin, const base::StringPiece& str_val)
+ : type_(STRING),
+ string_value_(str_val.as_string()),
+ int_value_(0),
+ origin_(origin) {
+}
+
+Value::~Value() {
+}
+
+// static
+const char* Value::DescribeType(Type t) {
+ switch (t) {
+ case NONE:
+ return "none";
+ case INTEGER:
+ return "integer";
+ case STRING:
+ return "string";
+ case LIST:
+ return "list";
+ default:
+ NOTREACHED();
+ return "UNKNOWN";
+ }
+}
+
+int64 Value::InterpretAsInt() const {
+ switch (type_) {
+ case NONE:
+ return 0;
+ case INTEGER:
+ return int_value_;
+ case STRING:
+ return string_value_.empty() ? 0 : 1;
+ case LIST:
+ return list_value_.empty() ? 0 : 1;
+ }
+ return 0;
+}
+
+std::string Value::ToString() const {
+ switch (type_) {
+ case NONE:
+ return "<void>";
+ case INTEGER:
+ return base::Int64ToString(int_value_);
+ case STRING:
+ return string_value_;
+ case LIST: {
+ std::string result = "[";
+ for (size_t i = 0; i < list_value_.size(); i++) {
+ if (i > 0)
+ result += ", ";
+ // TODO(brettw) maybe also want to escape quotes in the string.
+ if (list_value_[i].type() == STRING)
+ result += std::string("\"") + list_value_[i].ToString() + "\"";
+ else
+ result += list_value_[i].ToString();
+ }
+ result.push_back(']');
+ return result;
+ }
+ }
+ return std::string();
+}
+
+bool Value::VerifyTypeIs(Type t, Err* err) const {
+ if (type_ == t)
+ return true;
+
+ *err = Err(origin(), std::string("This is not a ") + DescribeType(t) + ".");
+ return false;
+}
+
+bool Value::operator==(const Value& other) const {
+ if (type_ != other.type_)
+ return false;
+
+ switch (type_) {
+ case Value::INTEGER:
+ return int_value() == other.int_value();
+ case Value::STRING:
+ return string_value() == other.string_value();
+ case Value::LIST:
+ if (list_value().size() != other.list_value().size())
+ return false;
+ for (size_t i = 0; i < list_value().size(); i++) {
+ if (list_value()[i] != other.list_value()[i])
+ return false;
+ }
+ return true;
+ default:
+ return false;
+ }
+}
+
+bool Value::operator!=(const Value& other) const {
+ return !operator==(other);
+}
diff --git a/tools/gn/value.h b/tools/gn/value.h
new file mode 100644
index 0000000..8802bff
--- /dev/null
+++ b/tools/gn/value.h
@@ -0,0 +1,91 @@
+// 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_VALUE_H_
+#define TOOLS_GN_VALUE_H_
+
+#include "base/basictypes.h"
+#include "base/logging.h"
+#include "base/strings/string_piece.h"
+#include "tools/gn/err.h"
+
+class ParseNode;
+
+// Represents a variable value in the interpreter.
+class Value {
+ public:
+ enum Type {
+ NONE = 0,
+ INTEGER,
+ STRING,
+ LIST
+ };
+
+ Value();
+ Value(const ParseNode* origin, Type t);
+ Value(const ParseNode* origin, int64 int_val);
+ Value(const ParseNode* origin, const base::StringPiece& str_val);
+ ~Value();
+
+ Type type() const { return type_; }
+
+ // Returns a string describing the given type.
+ static const char* DescribeType(Type t);
+
+ // Returns the node that made this. May be NULL.
+ const ParseNode* origin() const { return origin_; }
+ void set_origin(const ParseNode* o) { origin_ = o; }
+
+ int64& int_value() {
+ DCHECK(type_ == INTEGER);
+ return int_value_;
+ }
+ const int64& int_value() const {
+ DCHECK(type_ == INTEGER);
+ return int_value_;
+ }
+
+ std::string& string_value() {
+ DCHECK(type_ == STRING);
+ return string_value_;
+ }
+ const std::string& string_value() const {
+ DCHECK(type_ == STRING);
+ return string_value_;
+ }
+
+ std::vector<Value>& list_value() {
+ DCHECK(type_ == LIST);
+ return list_value_;
+ }
+ const std::vector<Value>& list_value() const {
+ DCHECK(type_ == LIST);
+ return list_value_;
+ }
+
+ // Returns the current value converted to an int, normally used for
+ // boolean operations. Undefined variables, empty lists, and empty strings
+ // are all interpreted as 0, otherwise 1.
+ int64 InterpretAsInt() const;
+
+ // Converts the given value to a string.
+ std::string ToString() const;
+
+ // Verifies that the value is of the given type. If it isn't, returns
+ // false and sets the error.
+ bool VerifyTypeIs(Type t, Err* err) const;
+
+ // Compares values. Only the "value" is compared, not the origin.
+ bool operator==(const Value& other) const;
+ bool operator!=(const Value& other) const;
+
+ private:
+ Type type_;
+ std::string string_value_;
+ int64 int_value_;
+ std::vector<Value> list_value_;
+ const ParseNode* origin_;
+};
+
+#endif // TOOLS_GN_VALUE_H_
diff --git a/tools/gn/value_extractors.cc b/tools/gn/value_extractors.cc
new file mode 100644
index 0000000..56a2be2
--- /dev/null
+++ b/tools/gn/value_extractors.cc
@@ -0,0 +1,102 @@
+// 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/value_extractors.h"
+
+#include "tools/gn/err.h"
+#include "tools/gn/label.h"
+#include "tools/gn/source_dir.h"
+#include "tools/gn/source_file.h"
+
+namespace {
+
+// This extractor rejects files with system-absolute file paths. If we need
+// that in the future, we'll have to add some flag to control this.
+struct RelativeFileConverter {
+ RelativeFileConverter(const SourceDir& current_dir_in)
+ : current_dir(current_dir_in) {}
+ bool operator()(const Value& v, SourceFile* out, Err* err) const {
+ if (!v.VerifyTypeIs(Value::STRING, err))
+ return false;
+ *out = current_dir.ResolveRelativeFile(v.string_value());
+ if (out->is_system_absolute()) {
+ *err = Err(v, "System-absolute file path.",
+ "You can't list a system-absolute file path here. Please include "
+ "only files in\nthe source tree. Maybe you meant to begin with two "
+ "slashes to indicate an\nabsolute path in the source tree?");
+ return false;
+ }
+ return true;
+ }
+ const SourceDir& current_dir;
+};
+
+struct RelativeDirConverter {
+ RelativeDirConverter(const SourceDir& current_dir_in)
+ : current_dir(current_dir_in) {}
+ bool operator()(const Value& v, SourceDir* out, Err* err) const {
+ if (!v.VerifyTypeIs(Value::STRING, err))
+ return false;
+ *out = current_dir.ResolveRelativeDir(v.string_value());
+ return true;
+ }
+ const SourceDir& current_dir;
+};
+
+struct LabelResolver {
+ LabelResolver(const SourceDir& current_dir_in,
+ const Label& current_toolchain_in)
+ : current_dir(current_dir_in),
+ current_toolchain(current_toolchain_in) {}
+ bool operator()(const Value& v, Label* out, Err* err) const {
+ if (!v.VerifyTypeIs(Value::STRING, err))
+ return false;
+ *out = Label::Resolve(current_dir, current_toolchain, v, err);
+ return !err->has_error();
+ }
+ const SourceDir& current_dir;
+ const Label& current_toolchain;
+};
+
+} // namespace
+
+bool ExtractListOfStringValues(const Value& value,
+ std::vector<std::string>* dest,
+ Err* err) {
+ if (!value.VerifyTypeIs(Value::LIST, err))
+ return false;
+ const std::vector<Value>& input_list = value.list_value();
+ dest->reserve(input_list.size());
+ for (size_t i = 0; i < input_list.size(); i++) {
+ if (!input_list[i].VerifyTypeIs(Value::STRING, err))
+ return false;
+ dest->push_back(input_list[i].string_value());
+ }
+ return true;
+}
+
+bool ExtractListOfRelativeFiles(const Value& value,
+ const SourceDir& current_dir,
+ std::vector<SourceFile>* files,
+ Err* err) {
+ return ListValueExtractor(value, files, err,
+ RelativeFileConverter(current_dir));
+}
+
+bool ExtractListOfRelativeDirs(const Value& value,
+ const SourceDir& current_dir,
+ std::vector<SourceDir>* dest,
+ Err* err) {
+ return ListValueExtractor(value, dest, err,
+ RelativeDirConverter(current_dir));
+}
+
+bool ExtractListOfLabels(const Value& value,
+ const SourceDir& current_dir,
+ const Label& current_toolchain,
+ std::vector<Label>* dest,
+ Err* err) {
+ return ListValueExtractor(value, dest, err,
+ LabelResolver(current_dir, current_toolchain));
+}
diff --git a/tools/gn/value_extractors.h b/tools/gn/value_extractors.h
new file mode 100644
index 0000000..556f44f
--- /dev/null
+++ b/tools/gn/value_extractors.h
@@ -0,0 +1,57 @@
+// 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_VALUE_EXTRACTORS_H_
+#define TOOLS_GN_VALUE_EXTRACTORS_H_
+
+#include <string>
+#include <vector>
+
+#include "tools/gn/value.h"
+
+class Err;
+class Label;
+class SourceDir;
+class SourceFile;
+
+// Sets the error and returns false on failure.
+template<typename T, class Converter>
+bool ListValueExtractor(const Value& value, std::vector<T>* dest,
+ Err* err,
+ const Converter& converter) {
+ if (!value.VerifyTypeIs(Value::LIST, err))
+ return false;
+ const std::vector<Value>& input_list = value.list_value();
+ dest->resize(input_list.size());
+ for (size_t i = 0; i < input_list.size(); i++) {
+ if (!converter(input_list[i], &(*dest)[i], err))
+ return false;
+ }
+ return true;
+}
+
+// On failure, returns false and sets the error.
+bool ExtractListOfStringValues(const Value& value,
+ std::vector<std::string>* dest,
+ Err* err);
+
+// Looks for a list of source files relative to a given current dir.
+bool ExtractListOfRelativeFiles(const Value& value,
+ const SourceDir& current_dir,
+ std::vector<SourceFile>* files,
+ Err* err);
+
+// Looks for a list of source directories relative to a given current dir.
+bool ExtractListOfRelativeDirs(const Value& value,
+ const SourceDir& current_dir,
+ std::vector<SourceDir>* dest,
+ Err* err);
+
+bool ExtractListOfLabels(const Value& value,
+ const SourceDir& current_dir,
+ const Label& current_toolchain,
+ std::vector<Label>* dest,
+ Err* err);
+
+#endif // TOOLS_GN_VALUE_EXTRACTORS_H_
