Home | History | Annotate | Download | only in gn 
      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_build_writer.h"
      6 
      7 #include <fstream>
      8 
      9 #include "base/command_line.h"
     10 #include "base/file_util.h"
     11 #include "base/process/process_handle.h"
     12 #include "base/strings/utf_string_conversions.h"
     13 #include "build/build_config.h"
     14 #include "tools/gn/build_settings.h"
     15 #include "tools/gn/escape.h"
     16 #include "tools/gn/filesystem_utils.h"
     17 #include "tools/gn/input_file_manager.h"
     18 #include "tools/gn/scheduler.h"
     19 #include "tools/gn/target.h"
     20 #include "tools/gn/trace.h"
     21 
     22 #if defined(OS_WIN)
     23 #include <windows.h>
     24 #endif
     25 
     26 namespace {
     27 
     28 std::string GetSelfInvocationCommand(const BuildSettings* build_settings) {
     29 #if defined(OS_WIN)
     30   wchar_t module[MAX_PATH];
     31   GetModuleFileName(NULL, module, MAX_PATH);
     32   //result = "\"" + WideToUTF8(module) + "\"";
     33   base::FilePath executable(module);
     34 #elif defined(OS_MACOSX)
     35   // FIXME(brettw) write this on Mac!
     36   base::FilePath executable("../Debug/gn");
     37 #else
     38   base::FilePath executable =
     39       base::GetProcessExecutablePath(base::GetCurrentProcessHandle());
     40 #endif
     41 
     42 /*
     43   // Append the root path.
     44   CommandLine* cmdline = CommandLine::ForCurrentProcess();
     45   result += " --root=\"" + FilePathToUTF8(settings->root_path()) + "\"";
     46 */
     47 
     48   CommandLine cmdline(executable);
     49   cmdline.AppendSwitchPath("--root", build_settings->root_path());
     50   cmdline.AppendSwitch("-q");  // Don't write output.
     51 
     52   EscapeOptions escape_shell;
     53   escape_shell.mode = ESCAPE_SHELL;
     54 #if defined(OS_WIN)
     55   // The command line code quoting varies by platform. We have one string,
     56   // possibly with spaces, that we want to quote. The Windows command line
     57   // quotes again, so we don't want quoting. The Posix one doesn't.
     58   escape_shell.inhibit_quoting = true;
     59 #endif
     60 
     61   const CommandLine& our_cmdline = *CommandLine::ForCurrentProcess();
     62   const CommandLine::SwitchMap& switches = our_cmdline.GetSwitches();
     63   for (CommandLine::SwitchMap::const_iterator i = switches.begin();
     64        i != switches.end(); ++i) {
     65     if (i->first != "q" && i->first != "root") {
     66       std::string escaped_value =
     67           EscapeString(FilePathToUTF8(i->second), escape_shell, NULL);
     68       cmdline.AppendSwitchASCII(i->first, escaped_value);
     69     }
     70   }
     71 
     72 #if defined(OS_WIN)
     73   return WideToUTF8(cmdline.GetCommandLineString());
     74 #else
     75   return cmdline.GetCommandLineString();
     76 #endif
     77 }
     78 
     79 }  // namespace
     80 
     81 NinjaBuildWriter::NinjaBuildWriter(
     82     const BuildSettings* build_settings,
     83     const std::vector<const Settings*>& all_settings,
     84     const std::vector<const Target*>& default_toolchain_targets,
     85     std::ostream& out,
     86     std::ostream& dep_out)
     87     : build_settings_(build_settings),
     88       all_settings_(all_settings),
     89       default_toolchain_targets_(default_toolchain_targets),
     90       out_(out),
     91       dep_out_(dep_out),
     92       path_output_(build_settings->build_dir(), ESCAPE_NINJA, true),
     93       helper_(build_settings) {
     94 }
     95 
     96 NinjaBuildWriter::~NinjaBuildWriter() {
     97 }
     98 
     99 void NinjaBuildWriter::Run() {
    100   WriteNinjaRules();
    101   WriteSubninjas();
    102   WritePhonyAndAllRules();
    103 }
    104 
    105 // static
    106 bool NinjaBuildWriter::RunAndWriteFile(
    107     const BuildSettings* build_settings,
    108     const std::vector<const Settings*>& all_settings,
    109     const std::vector<const Target*>& default_toolchain_targets) {
    110   ScopedTrace trace(TraceItem::TRACE_FILE_WRITE, "build.ninja");
    111 
    112   base::FilePath ninja_file(build_settings->GetFullPath(
    113       SourceFile(build_settings->build_dir().value() + "build.ninja")));
    114   base::CreateDirectory(ninja_file.DirName());
    115 
    116   std::ofstream file;
    117   file.open(FilePathToUTF8(ninja_file).c_str(),
    118             std::ios_base::out | std::ios_base::binary);
    119   if (file.fail())
    120     return false;
    121 
    122   std::ofstream depfile;
    123   depfile.open((FilePathToUTF8(ninja_file) + ".d").c_str(),
    124                std::ios_base::out | std::ios_base::binary);
    125   if (depfile.fail())
    126     return false;
    127 
    128   NinjaBuildWriter gen(build_settings, all_settings,
    129                        default_toolchain_targets, file, depfile);
    130   gen.Run();
    131   return true;
    132 }
    133 
    134 void NinjaBuildWriter::WriteNinjaRules() {
    135   out_ << "rule gn\n";
    136   out_ << "  command = " << GetSelfInvocationCommand(build_settings_) << "\n";
    137   out_ << "  description = Regenerating ninja files\n\n";
    138 
    139   // This rule will regenerate the ninja files when any input file has changed.
    140   out_ << "build build.ninja: gn\n"
    141        << "  depfile = build.ninja.d\n";
    142 
    143   // Provide a way to force regenerating ninja files if the user is suspicious
    144   // something is out-of-date. This will be "ninja refresh".
    145   out_ << "\nbuild refresh: gn\n";
    146 
    147   // Provide a way to see what flags are associated with this build:
    148   // This will be "ninja show".
    149   const CommandLine& our_cmdline = *CommandLine::ForCurrentProcess();
    150   std::string args = our_cmdline.GetSwitchValueASCII("args");
    151   out_ << "rule echo\n";
    152   out_ << "  command = echo $text\n";
    153   out_ << "  description = ECHO $desc\n";
    154   out_ << "build show: echo\n";
    155   out_ << "  desc = build arguments:\n";
    156   out_ << "  text = "
    157        << (args.empty() ? std::string("No build args, using defaults.") : args)
    158        << "\n";
    159 
    160   // Input build files. These go in the ".d" file. If we write them as
    161   // dependencies in the .ninja file itself, ninja will expect the files to
    162   // exist and will error if they don't. When files are listed in a depfile,
    163   // missing files are ignored.
    164   dep_out_ << "build.ninja:";
    165   std::vector<base::FilePath> input_files;
    166   g_scheduler->input_file_manager()->GetAllPhysicalInputFileNames(&input_files);
    167   for (size_t i = 0; i < input_files.size(); i++)
    168     dep_out_ << " " << FilePathToUTF8(input_files[i]);
    169 
    170   // Other files read by the build.
    171   std::vector<base::FilePath> other_files = g_scheduler->GetGenDependencies();
    172   for (size_t i = 0; i < other_files.size(); i++)
    173     dep_out_ << " " << FilePathToUTF8(other_files[i]);
    174 
    175   out_ << std::endl;
    176 }
    177 
    178 void NinjaBuildWriter::WriteSubninjas() {
    179   for (size_t i = 0; i < all_settings_.size(); i++) {
    180     out_ << "subninja ";
    181     path_output_.WriteFile(out_,
    182                            helper_.GetNinjaFileForToolchain(all_settings_[i]));
    183     out_ << std::endl;
    184   }
    185   out_ << std::endl;
    186 }
    187 
    188 void NinjaBuildWriter::WritePhonyAndAllRules() {
    189   std::string all_rules;
    190 
    191   // Write phony rules for the default toolchain (don't do other toolchains or
    192   // we'll get naming conflicts).
    193   for (size_t i = 0; i < default_toolchain_targets_.size(); i++) {
    194     const Target* target = default_toolchain_targets_[i];
    195 
    196     OutputFile target_file = helper_.GetTargetOutputFile(target);
    197     if (target_file.value() != target->label().name()) {
    198       out_ << "build " << target->label().name() << ": phony ";
    199       path_output_.WriteFile(out_, target_file);
    200       out_ << std::endl;
    201     }
    202 
    203     if (!all_rules.empty())
    204       all_rules.append(" $\n    ");
    205     all_rules.append(target_file.value());
    206   }
    207 
    208   if (!all_rules.empty()) {
    209     out_ << "\nbuild all: phony " << all_rules << std::endl;
    210     out_ << "default all" << std::endl;
    211   }
    212 }
    213 
    214