1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
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();
}
|
