OLD | NEW |
| (Empty) |
1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "tools/gn/target_manager.h" | |
6 | |
7 #include <deque> | |
8 | |
9 #include "base/bind.h" | |
10 #include "base/strings/string_piece.h" | |
11 #include "tools/gn/build_settings.h" | |
12 #include "tools/gn/err.h" | |
13 #include "tools/gn/filesystem_utils.h" | |
14 #include "tools/gn/item_node.h" | |
15 #include "tools/gn/scheduler.h" | |
16 #include "tools/gn/toolchain_manager.h" | |
17 #include "tools/gn/value.h" | |
18 | |
19 TargetManager::TargetManager(const BuildSettings* build_settings) | |
20 : build_settings_(build_settings) { | |
21 } | |
22 | |
23 TargetManager::~TargetManager() { | |
24 } | |
25 | |
26 Target* TargetManager::GetTarget(const Label& label, | |
27 const LocationRange& specified_from_here, | |
28 Target* dep_from, | |
29 Err* err) { | |
30 DCHECK(!label.is_null()); | |
31 DCHECK(!label.toolchain_dir().value().empty()); | |
32 DCHECK(!label.toolchain_name().empty()); | |
33 | |
34 base::AutoLock lock(build_settings_->item_tree().lock()); | |
35 | |
36 ItemNode* target_node = | |
37 build_settings_->item_tree().GetExistingNodeLocked(label); | |
38 Target* target = NULL; | |
39 if (!target_node) { | |
40 // First time we've seen this, may need to load the file. | |
41 | |
42 // Compute the settings. The common case is that we have a dep_from and | |
43 // the toolchains match, so we can use the settings from there rather than | |
44 // querying the toolchain manager (which requires locking, etc.). | |
45 const Settings* settings; | |
46 if (dep_from && dep_from->label().ToolchainsEqual(label)) { | |
47 settings = dep_from->settings(); | |
48 } else { | |
49 settings = | |
50 build_settings_->toolchain_manager().GetSettingsForToolchainLocked( | |
51 specified_from_here, label.GetToolchainLabel(), err); | |
52 if (!settings) | |
53 return NULL; | |
54 } | |
55 | |
56 target = new Target(settings, label); | |
57 | |
58 target_node = new ItemNode(target); | |
59 if (settings->greedy_target_generation()) { | |
60 if (!target_node->SetShouldGenerate(build_settings_, err)) | |
61 return NULL; | |
62 } | |
63 target_node->set_originally_referenced_from_here(specified_from_here); | |
64 | |
65 build_settings_->item_tree().AddNodeLocked(target_node); | |
66 | |
67 // We're generating a node when there is no referencing one. | |
68 if (!dep_from) | |
69 target_node->set_generated_from_here(specified_from_here); | |
70 | |
71 } else if ((target = target_node->item()->AsTarget())) { | |
72 // Previously saw this item as a target. | |
73 | |
74 // If we have no dep_from, we're generating it. | |
75 if (!dep_from) { | |
76 // In this case, it had better not already be generated. | |
77 if (target_node->state() != ItemNode::REFERENCED) { | |
78 *err = Err(specified_from_here, | |
79 "Duplicate target.", | |
80 "\"" + label.GetUserVisibleName(true) + | |
81 "\" being defined here."); | |
82 err->AppendSubErr(Err(target_node->generated_from_here(), | |
83 "Originally defined here.")); | |
84 return NULL; | |
85 } else { | |
86 target_node->set_generated_from_here(specified_from_here); | |
87 } | |
88 } | |
89 } else { | |
90 // Error, we previously saw this thing as a non-target. | |
91 *err = Err(specified_from_here, "Not previously a target.", | |
92 "The target being declared here was previously seen referenced as a " + | |
93 target_node->item()->GetItemTypeName()); | |
94 err->AppendSubErr(Err(target_node->originally_referenced_from_here(), | |
95 "Originally referenced from here.")); | |
96 return NULL; | |
97 } | |
98 | |
99 // Keep a record of the guy asking us for this dependency. We know if | |
100 // somebody is adding a dependency, that guy it himself not resolved. | |
101 if (dep_from && target_node->state() != ItemNode::RESOLVED) { | |
102 ItemNode* from_node = dep_from->item_node(); | |
103 if (!from_node->AddDependency(build_settings_, specified_from_here, | |
104 target_node, err)) | |
105 return NULL; | |
106 } | |
107 | |
108 return target; | |
109 } | |
110 | |
111 bool TargetManager::TargetGenerationComplete(const Label& label, | |
112 Err* err) { | |
113 base::AutoLock lock(build_settings_->item_tree().lock()); | |
114 return build_settings_->item_tree().MarkItemDefinedLocked( | |
115 build_settings_, label, err); | |
116 } | |
117 | |
118 void TargetManager::GetAllTargets( | |
119 std::vector<const Target*>* all_targets) const { | |
120 base::AutoLock lock(build_settings_->item_tree().lock()); | |
121 | |
122 std::vector<const Item*> all_items; | |
123 build_settings_->item_tree().GetAllItemsLocked(&all_items); | |
124 for (size_t i = 0; i < all_items.size(); i++) { | |
125 const Target* t = all_items[i]->AsTarget(); | |
126 if (t) | |
127 all_targets->push_back(t); | |
128 } | |
129 } | |
OLD | NEW |