src/tools/gn/ninja_writer.cc

   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/ninja_writer.h"
   6
   7 #include "tools/gn/builder.h"
   8 #include "tools/gn/loader.h"
   9 #include "tools/gn/location.h"
  10 #include "tools/gn/ninja_build_writer.h"
  11 #include "tools/gn/ninja_toolchain_writer.h"
  12 #include "tools/gn/settings.h"
  13
  14 NinjaWriter::NinjaWriter(const BuildSettings* build_settings,
  15                          Builder* builder)
  16     : build_settings_(build_settings),
  17       builder_(builder) {
  18 }
  19
  20 NinjaWriter::~NinjaWriter() {
  21 }
  22
  23 // static
  24 bool NinjaWriter::RunAndWriteFiles(const BuildSettings* build_settings,
  25                                    Builder* builder) {
  26   NinjaWriter writer(build_settings, builder);
  27
  28   std::vector<const Settings*> all_settings;
  29   std::vector<const Target*> default_targets;
  30   if (!writer.WriteToolchains(&all_settings, &default_targets))
  31     return false;
  32   return writer.WriteRootBuildfiles(all_settings, default_targets);
  33 }
  34
  35 // static
  36 bool NinjaWriter::RunAndWriteToolchainFiles(
  37     const BuildSettings* build_settings,
  38     Builder* builder,
  39     std::vector<const Settings*>* all_settings) {
  40   NinjaWriter writer(build_settings, builder);
  41   std::vector<const Target*> default_targets;
  42   return writer.WriteToolchains(all_settings, &default_targets);
  43 }
  44
  45 bool NinjaWriter::WriteToolchains(std::vector<const Settings*>* all_settings,
  46                                   std::vector<const Target*>* default_targets) {
  47   // Categorize all targets by toolchain.
  48   typedef std::map<Label, std::vector<const Target*> > CategorizedMap;
  49   CategorizedMap categorized;
  50
  51   std::vector<const BuilderRecord*> all_records = builder_->GetAllRecords();
  52   for (size_t i = 0; i < all_records.size(); i++) {
  53     if (all_records[i]->type() == BuilderRecord::ITEM_TARGET &&
  54         all_records[i]->should_generate()) {
  55       categorized[all_records[i]->label().GetToolchainLabel()].push_back(
  56           all_records[i]->item()->AsTarget());
  57       }
  58   }
  59   if (categorized.empty()) {
  60     Err(Location(), "No targets.",
  61         "I could not find any targets to write, so I'm doing nothing.")
  62         .PrintToStdout();
  63     return false;
  64   }
  65
  66   Label default_label = builder_->loader()->GetDefaultToolchain();
  67
  68   // Write out the toolchain buildfiles, and also accumulate the set of
  69   // all settings and find the list of targets in the default toolchain.
  70   for (CategorizedMap::const_iterator i = categorized.begin();
  71        i != categorized.end(); ++i) {
  72     const Settings* settings =
  73         builder_->loader()->GetToolchainSettings(i->first);
  74     const Toolchain* toolchain = builder_->GetToolchain(i->first);
  75
  76     all_settings->push_back(settings);
  77     if (!NinjaToolchainWriter::RunAndWriteFile(settings, toolchain,
  78                                                i->second)) {
  79       Err(Location(),
  80           "Couldn't open toolchain buildfile(s) for writing").PrintToStdout();
  81       return false;
  82     }
  83   }
  84
  85   *default_targets = categorized[default_label];
  86   return true;
  87 }
  88
  89 bool NinjaWriter::WriteRootBuildfiles(
  90     const std::vector<const Settings*>& all_settings,
  91     const std::vector<const Target*>& default_targets) {
  92   // All Settings objects should have the same default toolchain, and there
  93   // should always be at least one settings object in the build.
  94   CHECK(!all_settings.empty());
  95   const Toolchain* default_toolchain =
  96       builder_->GetToolchain(all_settings[0]->default_toolchain_label());
  97
  98   // Write the root buildfile.
  99   if (!NinjaBuildWriter::RunAndWriteFile(build_settings_, all_settings,
 100                                          default_toolchain, default_targets)) {
 101     Err(Location(),
 102         "Couldn't open toolchain buildfile(s) for writing").PrintToStdout();
 103     return false;
 104   }
 105   return true;
 106 }