Support more configurability in GN toolchains

tools/gn/target.h

 // 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/action_values.h"
 #include "tools/gn/config_values.h"
 #include "tools/gn/item.h"
 #include "tools/gn/label_ptr.h"
 #include "tools/gn/ordered_set.h"
+#include "tools/gn/output_file.h"
 #include "tools/gn/source_file.h"
 #include "tools/gn/unique_vector.h"
 
 class InputFile;
 class Settings;
 class Token;
+class Toolchain;
 
 class Target : public Item {
  public:
   enum OutputType {
     UNKNOWN,
     GROUP,
     EXECUTABLE,
     SHARED_LIBRARY,
     STATIC_LIBRARY,
     SOURCE_SET,
@@ skipping 14 matching lines @@
   virtual Target* AsTarget() OVERRIDE;
   virtual const Target* AsTarget() const OVERRIDE;
   virtual void OnResolved() OVERRIDE;
 
   OutputType output_type() const { return output_type_; }
   void set_output_type(OutputType t) { output_type_ = t; }
 
   bool IsLinkable() const;
 
   // Will be the empty string to use the target label as the output name.
+  // See GetComputedOutputName().
   const std::string& output_name() const { return output_name_; }
   void set_output_name(const std::string& name) { output_name_ = name; }
 
+  // Returns the output name for this target, which is the output_name if
+  // specified, or the target label if not. If the flag is set, it will also
+  // include any output prefix specified on the tool (often "lib" on Linux).
+  //
+  // Because this depends on the tool for this target, the toolchain must
+  // have been set before calling.
+  std::string GetComputedOutputName(bool include_prefix) const;
+
   const std::string& output_extension() const { return output_extension_; }
   void set_output_extension(const std::string& extension) {
     output_extension_ = extension;
   }
 
   const FileList& sources() const { return sources_; }
   FileList& sources() { return sources_; }
 
   // Set to true when all sources are public. This is the default. In this case
   // the public headers list should be empty.
@@ skipping 73 matching lines @@
   ActionValues& action_values() { return action_values_; }
   const ActionValues& action_values() const { return action_values_; }
 
   const OrderedSet<SourceDir>& all_lib_dirs() const { return all_lib_dirs_; }
   const OrderedSet<std::string>& all_libs() const { return all_libs_; }
 
   const std::set<const Target*>& recursive_hard_deps() const {
     return recursive_hard_deps_;
   }
 
+  // The toolchain is only known once this target is resolved (all if its
+  // dependencies are known). They will be null until then. Generally, this can
+  // only be used during target writing.
+  const Toolchain* toolchain() const { return toolchain_; }
+
+  // Sets the toolchain. The toolchain must include a tool for this target
+  // or the error will be set and the function will return false. Unusually,
+  // this function's "err" output is optional since this is commonly used
+  // frequently by unit tests which become needlessly verbose.
+  bool SetToolchain(const Toolchain* toolchain, Err* err = NULL);
+
+  // Returns outputs from this target. The link output file is the one that
+  // other targets link to when they depend on this target. This will only be
+  // valid for libraries and will be empty for all other target types.
+  //
+  // The dependency output file is the file that should be used to express
+  // a dependency on this one. It could be the same as the link output file
+  // (this will be the case for static libraries). For shared libraries it
+  // could be the same or different than the link output file, depending on the
+  // system. For actions this will be the stamp file.
+  //
+  // These are only known once the target is resolved and will be empty before
+  // that. This is a cache of the files to prevent every target that depends on
+  // a given library from recomputing the same pattern.
+  const OutputFile& link_output_file() const {
+    return link_output_file_;
+  }
+  const OutputFile& dependency_output_file() const {
+    return dependency_output_file_;
+  }
+
  private:
   // Pulls necessary information from dependencies to this one when all
   // dependencies have been resolved.
   void PullDependentTargetInfo();
 
   // These each pull specific things from dependencies to this one when all
   // deps have been resolved.
   void PullForwardedDependentConfigs();
   void PullRecursiveHardDeps();
 
+  // Fills the link and dependency output files when a target is resolved.
+  void FillOutputFiles();
+
   OutputType output_type_;
   std::string output_name_;
   std::string output_extension_;
 
   FileList sources_;
   bool all_headers_public_;
   FileList public_headers_;
   FileList inputs_;
   FileList data_;
 
@@ skipping 32 matching lines @@
   OrderedSet<SourceDir> all_lib_dirs_;
   OrderedSet<std::string> all_libs_;
 
   // All hard deps from this target and all dependencies. Filled in when this
   // target is marked resolved. This will not include the current target.
   std::set<const Target*> recursive_hard_deps_;
 
   ConfigValues config_values_;  // Used for all binary targets.
   ActionValues action_values_;  // Used for action[_foreach] targets.
 
+  // Toolchain used by this target. Null until target is resolved.
+  const Toolchain* toolchain_;
+
+  // Output files. Null until the target is resolved.
+  OutputFile link_output_file_;
+  OutputFile dependency_output_file_;
+
   DISALLOW_COPY_AND_ASSIGN(Target);
 };
 
 namespace BASE_HASH_NAMESPACE {
 
 #if defined(COMPILER_GCC)
 template<> struct hash<const Target*> {
   std::size_t operator()(const Target* t) const {
     return reinterpret_cast<std::size_t>(t);
   }
 };
 #elif defined(COMPILER_MSVC)
 inline size_t hash_value(const Target* t) {
   return reinterpret_cast<size_t>(t);
 }
 #endif  // COMPILER...
 
 }  // namespace BASE_HASH_NAMESPACE
 
 #endif  // TOOLS_GN_TARGET_H_