Add get_target_outputs function to GN

tools/gn/file_template.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 "tools/gn/file_template.h"
 
 #include <algorithm>
 #include <iostream>
 
 #include "tools/gn/escape.h"
@@ skipping 73 matching lines @@
   ParseInput(t, err);
 }
 
 FileTemplate::FileTemplate(const std::vector<std::string>& t)
     : has_substitutions_(false) {
   std::fill(types_required_, &types_required_[Subrange::NUM_TYPES], false);
   for (size_t i = 0; i < t.size(); i++)
     ParseOneTemplateString(t[i]);
 }
 
+FileTemplate::FileTemplate(const std::vector<SourceFile>& t)
+    : has_substitutions_(false) {
+  std::fill(types_required_, &types_required_[Subrange::NUM_TYPES], false);
+  for (size_t i = 0; i < t.size(); i++)
+    ParseOneTemplateString(t[i].value());
+}
+
 FileTemplate::~FileTemplate() {
 }
 
 // static
 FileTemplate FileTemplate::GetForTargetOutputs(const Target* target) {
   const Target::FileList& outputs = target->action_values().outputs();
   std::vector<std::string> output_template_args;
   for (size_t i = 0; i < outputs.size(); i++)
     output_template_args.push_back(outputs[i].value());
   return FileTemplate(output_template_args);
@@ skipping 10 matching lines @@
                          Err* err) const {
   if (!sources.VerifyTypeIs(Value::LIST, err))
     return;
   dest->reserve(sources.list_value().size() * templates_.container().size());
 
   // Temporary holding place, allocate outside to re-use- buffer.
   std::vector<std::string> string_output;
 
   const std::vector<Value>& sources_list = sources.list_value();
   for (size_t i = 0; i < sources_list.size(); i++) {
+    string_output.clear();
     if (!sources_list[i].VerifyTypeIs(Value::STRING, err))
       return;
 
     ApplyString(sources_list[i].string_value(), &string_output);
     for (size_t out_i = 0; out_i < string_output.size(); out_i++)
       dest->push_back(Value(origin, string_output[out_i]));
   }
 }
 
 void FileTemplate::ApplyString(const std::string& str,
                                std::vector<std::string>* output) const {
   // Compute all substitutions needed so we can just do substitutions below.
   // We skip the LITERAL one since that varies each time.
   std::string subst[Subrange::NUM_TYPES];
   for (int i = 1; i < Subrange::NUM_TYPES; i++) {
     if (types_required_[i])
       subst[i] = GetSubstitution(str, static_cast<Subrange::Type>(i));
   }
 
-  output->resize(templates_.container().size());
+  size_t first_output_index = output->size();
+  output->resize(output->size() + templates_.container().size());
   for (size_t template_i = 0;
        template_i < templates_.container().size(); template_i++) {
     const Template& t = templates_[template_i];
-    (*output)[template_i].clear();
+    std::string& cur_output = (*output)[first_output_index + template_i];
     for (size_t subrange_i = 0; subrange_i < t.container().size();
          subrange_i++) {
       if (t[subrange_i].type == Subrange::LITERAL)
-        (*output)[template_i].append(t[subrange_i].literal);
+        cur_output.append(t[subrange_i].literal);
       else
-        (*output)[template_i].append(subst[t[subrange_i].type]);
+        cur_output.append(subst[t[subrange_i].type]);
     }
   }
 }
 
 void FileTemplate::WriteWithNinjaExpansions(std::ostream& out) const {
   EscapeOptions escape_options;
   escape_options.mode = ESCAPE_NINJA_SHELL;
   escape_options.inhibit_quoting = true;
 
   for (size_t template_i = 0;
@@ skipping 131 matching lines @@
       cur = next + arraysize(kSourceFilePart) - 1;
     } else {
       // If it's not a match, treat it like a one-char literal (this will be
       // rare, so it's not worth the bother to add to the previous literal) so
       // we can keep going.
       t.container().push_back(Subrange(Subrange::LITERAL, "{"));
       cur = next + 1;
     }
   }
 }