Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(51)

Unified Diff: tools/gn/function_toolchain.cc

Issue 21114002: Add initial prototype for the GN meta-buildsystem. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: add owners and readme Created 7 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « tools/gn/function_template.cc ('k') | tools/gn/function_write_file.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: tools/gn/function_toolchain.cc
diff --git a/tools/gn/function_toolchain.cc b/tools/gn/function_toolchain.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b78c639aca2c2b7cbceac4ca6b60986ba10c6255
--- /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();
+}
« no previous file with comments | « tools/gn/function_template.cc ('k') | tools/gn/function_write_file.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698