Add get_target_outputs function to GN

tools/gn/scope.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_SCOPE_H_
 #define TOOLS_GN_SCOPE_H_
 
 #include <map>
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/scoped_vector.h"
 #include "tools/gn/err.h"
 #include "tools/gn/pattern.h"
 #include "tools/gn/source_dir.h"
 #include "tools/gn/value.h"
 
 class FunctionCallNode;
 class ImportManager;
+class Item;
 class ParseNode;
 class Settings;
 class TargetManager;
 class Template;
 
 // Scope for the script execution.
 //
 // Scopes are nested. Writing goes into the toplevel scope, reading checks
 // values resursively down the stack until a match is found or there are no
 // more containing scopes.
 //
 // A containing scope can be const or non-const. The const containing scope is
 // used primarily to refer to the master build config which is shared across
 // many invocations. A const containing scope, however, prevents us from
 // marking variables "used" which prevents us from issuing errors on unused
 // variables. So you should use a non-const containing scope whenever possible.
 class Scope {
  public:
   typedef base::hash_map<base::StringPiece, Value> KeyValueMap;
+  // Holds an owning list of scoped_ptrs of Items (since we can't make a vector
+  // of scoped_ptrs).
+  typedef ScopedVector< scoped_ptr<Item> > ItemVector;
 
   // Allows code to provide values for built-in variables. This class will
   // automatically register itself on construction and deregister itself on
   // destruction.
   class ProgrammaticProvider {
    public:
     ProgrammaticProvider(Scope* scope) : scope_(scope) {
       scope_->AddProvider(this);
     }
     ~ProgrammaticProvider() {
@@ skipping 167 matching lines @@
   void SetProcessingImport();
   void ClearProcessingImport();
   bool IsProcessingImport() const;
 
   // The source directory associated with this scope. This will check embedded
   // scopes until it finds a nonempty source directory. This will default to
   // an empty dir if no containing scope has a source dir set.
   const SourceDir& GetSourceDir() const;
   void set_source_dir(const SourceDir& d) { source_dir_ = d; }
 
+  // The item collector is where Items (Targets, Configs, etc.) go that have
+  // been defined. If a scope can generate items, this non-owning pointer will
+  // point to the storage for such items. The creator of this scope will be
+  // responsible for setting up the collector and then dealing with the
+  // collected items once execution of the context is complete.
+  //
+  // The items in a scope are collected as we go and then dispatched at the end
+  // of execution of a scope so that we can query the previously-generated
+  // targets (like getting the outputs).
+  //
+  // This can be null if the current scope can not generate items (like for
+  // imports and such).
+  //
+  // When retrieving the collector, the non-const scopes are recursively
+  // queried. The collector is not copied for closures, etc.
+  void set_item_collector(ItemVector* collector) {
+    item_collector_ = collector;
+  }
+  ItemVector* GetItemCollector();
+
   // Properties are opaque pointers that code can use to set state on a Scope
   // that it can retrieve later.
   //
   // The key should be a pointer to some use-case-specific object (to avoid
   // collisions, otherwise it doesn't matter). Memory management is up to the
   // setter. Setting the value to NULL will delete the property.
   //
   // Getting a property recursively searches all scopes, and the optional
   // |found_on_scope| variable will be filled with the actual scope containing
   // the key (if the pointer is non-NULL).
@@ skipping 39 matching lines @@
   NamedScopeMap target_defaults_;
 
   // Null indicates not set and that we should fallback to the containing
   // scope's filter.
   scoped_ptr<PatternList> sources_assignment_filter_;
 
   // Owning pointers, must be deleted.
   typedef std::map<std::string, const Template*> TemplateMap;
   TemplateMap templates_;
 
+  ItemVector* item_collector_;
+
   // Opaque pointers. See SetProperty() above.
   typedef std::map<const void*, void*> PropertyMap;
   PropertyMap properties_;
 
   typedef std::set<ProgrammaticProvider*> ProviderSet;
   ProviderSet programmatic_providers_;
 
   SourceDir source_dir_;
 
   DISALLOW_COPY_AND_ASSIGN(Scope);
 };
 
 #endif  // TOOLS_GN_SCOPE_H_