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 #include <map> 9 10 #include "base/command_line.h" 11 #include "base/file_util.h" 12 #include "base/path_service.h" 13 #include "base/process/process_handle.h" 14 #include "base/strings/string_util.h" 15 #include "base/strings/utf_string_conversions.h" 16 #include "build/build_config.h" 17 #include "tools/gn/build_settings.h" 18 #include "tools/gn/escape.h" 19 #include "tools/gn/filesystem_utils.h" 20 #include "tools/gn/input_file_manager.h" 21 #include "tools/gn/scheduler.h" 22 #include "tools/gn/target.h" 23 #include "tools/gn/trace.h" 24 25 #if defined(OS_WIN) 26 #include <windows.h> 27 #endif 28 29 namespace { 30 31 std::string GetSelfInvocationCommand(const BuildSettings* build_settings) { 32 base::FilePath executable; 33 PathService::Get(base::FILE_EXE, &executable); 34 35 CommandLine cmdline(executable.NormalizePathSeparatorsTo('/')); 36 cmdline.AppendArg("gen"); 37 cmdline.AppendArg(build_settings->build_dir().value()); 38 cmdline.AppendSwitchPath("--root", build_settings->root_path()); 39 cmdline.AppendSwitch("-q"); // Don't write output. 40 41 EscapeOptions escape_shell; 42 escape_shell.mode = ESCAPE_NINJA_COMMAND; 43 #if defined(OS_WIN) 44 // The command line code quoting varies by platform. We have one string, 45 // possibly with spaces, that we want to quote. The Windows command line 46 // quotes again, so we don't want quoting. The Posix one doesn't. 47 escape_shell.inhibit_quoting = true; 48 #endif 49 50 const CommandLine& our_cmdline = *CommandLine::ForCurrentProcess(); 51 const CommandLine::SwitchMap& switches = our_cmdline.GetSwitches(); 52 for (CommandLine::SwitchMap::const_iterator i = switches.begin(); 53 i != switches.end(); ++i) { 54 // Only write arguments we haven't already written. Always skip "args" 55 // since those will have been written to the file and will be used 56 // implicitly in the future. Keeping --args would mean changes to the file 57 // would be ignored. 58 if (i->first != "q" && i->first != "root" && i->first != "args") { 59 std::string escaped_value = 60 EscapeString(FilePathToUTF8(i->second), escape_shell, NULL); 61 cmdline.AppendSwitchASCII(i->first, escaped_value); 62 } 63 } 64 65 #if defined(OS_WIN) 66 return base::WideToUTF8(cmdline.GetCommandLineString()); 67 #else 68 return cmdline.GetCommandLineString(); 69 #endif 70 } 71 72 } // namespace 73 74 NinjaBuildWriter::NinjaBuildWriter( 75 const BuildSettings* build_settings, 76 const std::vector<const Settings*>& all_settings, 77 const std::vector<const Target*>& default_toolchain_targets, 78 std::ostream& out, 79 std::ostream& dep_out) 80 : build_settings_(build_settings), 81 all_settings_(all_settings), 82 default_toolchain_targets_(default_toolchain_targets), 83 out_(out), 84 dep_out_(dep_out), 85 path_output_(build_settings->build_dir(), ESCAPE_NINJA), 86 helper_(build_settings) { 87 } 88 89 NinjaBuildWriter::~NinjaBuildWriter() { 90 } 91 92 void NinjaBuildWriter::Run() { 93 WriteNinjaRules(); 94 WriteSubninjas(); 95 WritePhonyAndAllRules(); 96 } 97 98 // static 99 bool NinjaBuildWriter::RunAndWriteFile( 100 const BuildSettings* build_settings, 101 const std::vector<const Settings*>& all_settings, 102 const std::vector<const Target*>& default_toolchain_targets) { 103 ScopedTrace trace(TraceItem::TRACE_FILE_WRITE, "build.ninja"); 104 105 base::FilePath ninja_file(build_settings->GetFullPath( 106 SourceFile(build_settings->build_dir().value() + "build.ninja"))); 107 base::CreateDirectory(ninja_file.DirName()); 108 109 std::ofstream file; 110 file.open(FilePathToUTF8(ninja_file).c_str(), 111 std::ios_base::out | std::ios_base::binary); 112 if (file.fail()) 113 return false; 114 115 std::ofstream depfile; 116 depfile.open((FilePathToUTF8(ninja_file) + ".d").c_str(), 117 std::ios_base::out | std::ios_base::binary); 118 if (depfile.fail()) 119 return false; 120 121 NinjaBuildWriter gen(build_settings, all_settings, 122 default_toolchain_targets, file, depfile); 123 gen.Run(); 124 return true; 125 } 126 127 void NinjaBuildWriter::WriteNinjaRules() { 128 out_ << "rule gn\n"; 129 out_ << " command = " << GetSelfInvocationCommand(build_settings_) << "\n"; 130 out_ << " description = Regenerating ninja files\n\n"; 131 132 // This rule will regenerate the ninja files when any input file has changed. 133 out_ << "build build.ninja: gn\n" 134 << " generator = 1\n" 135 << " depfile = build.ninja.d\n"; 136 137 // Input build files. These go in the ".d" file. If we write them as 138 // dependencies in the .ninja file itself, ninja will expect the files to 139 // exist and will error if they don't. When files are listed in a depfile, 140 // missing files are ignored. 141 dep_out_ << "build.ninja:"; 142 std::vector<base::FilePath> input_files; 143 g_scheduler->input_file_manager()->GetAllPhysicalInputFileNames(&input_files); 144 for (size_t i = 0; i < input_files.size(); i++) 145 dep_out_ << " " << FilePathToUTF8(input_files[i]); 146 147 // Other files read by the build. 148 std::vector<base::FilePath> other_files = g_scheduler->GetGenDependencies(); 149 for (size_t i = 0; i < other_files.size(); i++) 150 dep_out_ << " " << FilePathToUTF8(other_files[i]); 151 152 out_ << std::endl; 153 } 154 155 void NinjaBuildWriter::WriteSubninjas() { 156 for (size_t i = 0; i < all_settings_.size(); i++) { 157 out_ << "subninja "; 158 path_output_.WriteFile(out_, 159 helper_.GetNinjaFileForToolchain(all_settings_[i])); 160 out_ << std::endl; 161 } 162 out_ << std::endl; 163 } 164 165 void NinjaBuildWriter::WritePhonyAndAllRules() { 166 std::string all_rules; 167 168 // Write phony rules for all uniquely-named targets in the default toolchain. 169 // Don't do other toolchains or we'll get naming conflicts, and if the name 170 // isn't unique, also skip it. The exception is for the toplevel targets 171 // which we also find. 172 std::map<std::string, int> small_name_count; 173 std::vector<const Target*> toplevel_targets; 174 for (size_t i = 0; i < default_toolchain_targets_.size(); i++) { 175 const Target* target = default_toolchain_targets_[i]; 176 const Label& label = target->label(); 177 small_name_count[label.name()]++; 178 179 // Look for targets with a name of the form 180 // dir = "//foo/", name = "foo" 181 // i.e. where the target name matches the top level directory. We will 182 // always write phony rules for these even if there is another target with 183 // the same short name. 184 const std::string& dir_string = label.dir().value(); 185 if (dir_string.size() == label.name().size() + 3 && // Size matches. 186 dir_string[0] == '/' && dir_string[1] == '/' && // "//" at beginning. 187 dir_string[dir_string.size() - 1] == '/' && // "/" at end. 188 dir_string.compare(2, label.name().size(), label.name()) == 0) 189 toplevel_targets.push_back(target); 190 } 191 192 for (size_t i = 0; i < default_toolchain_targets_.size(); i++) { 193 const Target* target = default_toolchain_targets_[i]; 194 const Label& label = target->label(); 195 OutputFile target_file = helper_.GetTargetOutputFile(target); 196 197 // Write the long name "foo/bar:baz" for the target "//foo/bar:baz". 198 std::string long_name = label.GetUserVisibleName(false); 199 base::TrimString(long_name, "/", &long_name); 200 WritePhonyRule(target, target_file, long_name); 201 202 // Write the directory name with no target name if they match 203 // (e.g. "//foo/bar:bar" -> "foo/bar"). 204 if (FindLastDirComponent(label.dir()) == label.name()) { 205 std::string medium_name = DirectoryWithNoLastSlash(label.dir()); 206 base::TrimString(medium_name, "/", &medium_name); 207 // That may have generated a name the same as the short name of the 208 // target which we already wrote. 209 if (medium_name != label.name()) 210 WritePhonyRule(target, target_file, medium_name); 211 } 212 213 // Write short names for ones which are unique. 214 if (small_name_count[label.name()] == 1) 215 WritePhonyRule(target, target_file, label.name()); 216 217 if (!all_rules.empty()) 218 all_rules.append(" $\n "); 219 all_rules.append(target_file.value()); 220 } 221 222 // Pick up phony rules for the toplevel targets with non-unique names (which 223 // would have been skipped in the above loop). 224 for (size_t i = 0; i < toplevel_targets.size(); i++) { 225 if (small_name_count[toplevel_targets[i]->label().name()] > 1) { 226 const Target* target = toplevel_targets[i]; 227 WritePhonyRule(target, helper_.GetTargetOutputFile(target), 228 target->label().name()); 229 } 230 } 231 232 if (!all_rules.empty()) { 233 out_ << "\nbuild all: phony " << all_rules << std::endl; 234 out_ << "default all" << std::endl; 235 } 236 } 237 238 void NinjaBuildWriter::WritePhonyRule(const Target* target, 239 const OutputFile& target_file, 240 const std::string& phony_name) { 241 if (target_file.value() == phony_name) 242 return; // No need for a phony rule. 243 244 EscapeOptions ninja_escape; 245 ninja_escape.mode = ESCAPE_NINJA; 246 247 // Escape for special chars Ninja will handle. 248 std::string escaped = EscapeString(phony_name, ninja_escape, NULL); 249 250 out_ << "build " << escaped << ": phony "; 251 path_output_.WriteFile(out_, target_file); 252 out_ << std::endl; 253 } 254