Add initial prototype for the GN meta-buildsystem.

tools/gn/command_desc.cc

+// 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;
+}