Shinichiro Hamaji | 1d545aa | 2015-06-23 15:29:13 +0900 | [diff] [blame] | 1 | // Copyright 2015 Google Inc. All rights reserved |
| 2 | // |
| 3 | // Licensed under the Apache License, Version 2.0 (the "License"); |
| 4 | // you may not use this file except in compliance with the License. |
| 5 | // You may obtain a copy of the License at |
| 6 | // |
| 7 | // http://www.apache.org/licenses/LICENSE-2.0 |
| 8 | // |
| 9 | // Unless required by applicable law or agreed to in writing, software |
| 10 | // distributed under the License is distributed on an "AS IS" BASIS, |
| 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 12 | // See the License for the specific language governing permissions and |
| 13 | // limitations under the License. |
| 14 | |
Fumitoshi Ukai | 744bb2b | 2015-06-25 00:10:52 +0900 | [diff] [blame] | 15 | // +build ignore |
| 16 | |
Shinichiro Hamaji | 0e74c54 | 2015-06-22 16:17:08 +0900 | [diff] [blame] | 17 | #include <limits.h> |
Dan Willemsen | fcc71f8 | 2017-10-11 18:35:09 -0700 | [diff] [blame] | 18 | #include <signal.h> |
Shinichiro Hamaji | 776ca30 | 2015-06-06 03:52:48 +0900 | [diff] [blame] | 19 | #include <stdio.h> |
Shinichiro Hamaji | 087cecd | 2015-07-06 19:51:58 +0900 | [diff] [blame] | 20 | #include <stdlib.h> |
Dan Willemsen | 3ce083f | 2017-10-11 22:17:48 -0700 | [diff] [blame] | 21 | #include <string.h> |
Shinichiro Hamaji | a4bb774 | 2015-07-31 11:27:30 +0900 | [diff] [blame] | 22 | #include <time.h> |
Shinichiro Hamaji | 0e74c54 | 2015-06-22 16:17:08 +0900 | [diff] [blame] | 23 | #include <unistd.h> |
Shinichiro Hamaji | 776ca30 | 2015-06-06 03:52:48 +0900 | [diff] [blame] | 24 | |
Shinichiro Hamaji | 1a444a8 | 2016-02-16 13:49:49 +0900 | [diff] [blame] | 25 | #include "affinity.h" |
Shinichiro Hamaji | 776ca30 | 2015-06-06 03:52:48 +0900 | [diff] [blame] | 26 | #include "dep.h" |
| 27 | #include "eval.h" |
| 28 | #include "exec.h" |
| 29 | #include "file.h" |
| 30 | #include "file_cache.h" |
| 31 | #include "fileutil.h" |
Shinichiro Hamaji | 5f57a99 | 2015-06-30 19:39:39 +0900 | [diff] [blame] | 32 | #include "find.h" |
Shinichiro Hamaji | 08808d3 | 2015-06-26 08:02:45 +0900 | [diff] [blame] | 33 | #include "flags.h" |
Shinichiro Hamaji | 776ca30 | 2015-06-06 03:52:48 +0900 | [diff] [blame] | 34 | #include "func.h" |
| 35 | #include "log.h" |
Shinichiro Hamaji | 5f86e1a | 2015-06-29 14:25:39 +0900 | [diff] [blame] | 36 | #include "ninja.h" |
Shinichiro Hamaji | 42b625f | 2015-06-16 23:07:21 +0900 | [diff] [blame] | 37 | #include "parser.h" |
Shinichiro Hamaji | 8ef0ce5 | 2016-01-19 18:07:43 +0900 | [diff] [blame] | 38 | #include "regen.h" |
Shinichiro Hamaji | 0d8e79b | 2015-06-30 03:29:35 +0900 | [diff] [blame] | 39 | #include "stats.h" |
Shinichiro Hamaji | 645cca7 | 2015-09-24 17:04:21 +0900 | [diff] [blame] | 40 | #include "stmt.h" |
Shinichiro Hamaji | 776ca30 | 2015-06-06 03:52:48 +0900 | [diff] [blame] | 41 | #include "string_piece.h" |
Shinichiro Hamaji | 0e74c54 | 2015-06-22 16:17:08 +0900 | [diff] [blame] | 42 | #include "stringprintf.h" |
Shinichiro Hamaji | 776ca30 | 2015-06-06 03:52:48 +0900 | [diff] [blame] | 43 | #include "strutil.h" |
Shinichiro Hamaji | e799275 | 2015-06-29 18:38:35 +0900 | [diff] [blame] | 44 | #include "symtab.h" |
Shinichiro Hamaji | cbd34cd | 2015-07-05 02:53:04 +0900 | [diff] [blame] | 45 | #include "timeutil.h" |
Shinichiro Hamaji | 776ca30 | 2015-06-06 03:52:48 +0900 | [diff] [blame] | 46 | #include "var.h" |
| 47 | |
Dan Willemsen | 834c6db | 2017-08-15 14:44:32 -0700 | [diff] [blame] | 48 | // We know that there are leaks in Kati. Turn off LeakSanitizer by default. |
| 49 | extern "C" const char* __asan_default_options() { |
Dan Willemsen | fcc71f8 | 2017-10-11 18:35:09 -0700 | [diff] [blame] | 50 | return "detect_leaks=0:allow_user_segv_handler=1"; |
Dan Willemsen | 834c6db | 2017-08-15 14:44:32 -0700 | [diff] [blame] | 51 | } |
| 52 | |
Shinichiro Hamaji | 776ca30 | 2015-06-06 03:52:48 +0900 | [diff] [blame] | 53 | static void Init() { |
| 54 | InitSymtab(); |
| 55 | InitFuncTable(); |
| 56 | InitDepNodePool(); |
Shinichiro Hamaji | 42b625f | 2015-06-16 23:07:21 +0900 | [diff] [blame] | 57 | InitParser(); |
Shinichiro Hamaji | 776ca30 | 2015-06-06 03:52:48 +0900 | [diff] [blame] | 58 | } |
| 59 | |
| 60 | static void Quit() { |
Shinichiro Hamaji | 0d8e79b | 2015-06-30 03:29:35 +0900 | [diff] [blame] | 61 | ReportAllStats(); |
| 62 | |
Shinichiro Hamaji | 42b625f | 2015-06-16 23:07:21 +0900 | [diff] [blame] | 63 | QuitParser(); |
Shinichiro Hamaji | 776ca30 | 2015-06-06 03:52:48 +0900 | [diff] [blame] | 64 | QuitDepNodePool(); |
| 65 | QuitFuncTable(); |
| 66 | QuitSymtab(); |
| 67 | } |
| 68 | |
Shinichiro Hamaji | e799275 | 2015-06-29 18:38:35 +0900 | [diff] [blame] | 69 | static void ReadBootstrapMakefile(const vector<Symbol>& targets, |
Shinichiro Hamaji | 645cca7 | 2015-09-24 17:04:21 +0900 | [diff] [blame] | 70 | vector<Stmt*>* stmts) { |
Dan Willemsen | 3ce083f | 2017-10-11 22:17:48 -0700 | [diff] [blame] | 71 | string bootstrap = |
| 72 | ("CC?=cc\n" |
Shinichiro Hamaji | d749b93 | 2015-07-13 20:51:15 -0700 | [diff] [blame] | 73 | #if defined(__APPLE__) |
Dan Willemsen | 3ce083f | 2017-10-11 22:17:48 -0700 | [diff] [blame] | 74 | "CXX?=c++\n" |
Shinichiro Hamaji | d749b93 | 2015-07-13 20:51:15 -0700 | [diff] [blame] | 75 | #else |
Dan Willemsen | 3ce083f | 2017-10-11 22:17:48 -0700 | [diff] [blame] | 76 | "CXX?=g++\n" |
Shinichiro Hamaji | d749b93 | 2015-07-13 20:51:15 -0700 | [diff] [blame] | 77 | #endif |
Dan Willemsen | 3ce083f | 2017-10-11 22:17:48 -0700 | [diff] [blame] | 78 | "AR?=ar\n" |
| 79 | // Pretend to be GNU make 3.81, for compatibility. |
| 80 | "MAKE_VERSION?=3.81\n" |
| 81 | "KATI?=ckati\n" |
| 82 | // Overwrite $SHELL environment variable. |
| 83 | "SHELL=/bin/sh\n" |
| 84 | // TODO: Add more builtin vars. |
Shinichiro Hamaji | 0e74c54 | 2015-06-22 16:17:08 +0900 | [diff] [blame] | 85 | |
Dan Willemsen | 3ce083f | 2017-10-11 22:17:48 -0700 | [diff] [blame] | 86 | // http://www.gnu.org/software/make/manual/make.html#Catalogue-of-Rules |
| 87 | // The document above is actually not correct. See default.c: |
| 88 | // http://git.savannah.gnu.org/cgit/make.git/tree/default.c?id=4.1 |
| 89 | ".c.o:\n" |
| 90 | "\t$(CC) $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c -o $@ $<\n" |
| 91 | ".cc.o:\n" |
| 92 | "\t$(CXX) $(CXXFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c -o $@ $<\n" |
| 93 | // TODO: Add more builtin rules. |
| 94 | ); |
Shinichiro Hamaji | 003d06e | 2015-09-09 18:22:04 +0900 | [diff] [blame] | 95 | if (g_flags.generate_ninja) { |
Shinichiro Hamaji | b6a0454 | 2015-09-09 17:37:41 +0900 | [diff] [blame] | 96 | bootstrap += StringPrintf("MAKE?=make -j%d\n", |
Shinichiro Hamaji | 9dce444 | 2015-12-05 11:05:00 +0900 | [diff] [blame] | 97 | g_flags.num_jobs <= 1 ? 1 : g_flags.num_jobs / 2); |
Shinichiro Hamaji | b6a0454 | 2015-09-09 17:37:41 +0900 | [diff] [blame] | 98 | } else { |
| 99 | bootstrap += StringPrintf("MAKE?=%s\n", |
Shinichiro Hamaji | 003d06e | 2015-09-09 18:22:04 +0900 | [diff] [blame] | 100 | JoinStrings(g_flags.subkati_args, " ").c_str()); |
Shinichiro Hamaji | b6a0454 | 2015-09-09 17:37:41 +0900 | [diff] [blame] | 101 | } |
Dan Willemsen | 3ce083f | 2017-10-11 22:17:48 -0700 | [diff] [blame] | 102 | bootstrap += |
| 103 | StringPrintf("MAKECMDGOALS?=%s\n", JoinSymbols(targets, " ").c_str()); |
Shinichiro Hamaji | 0e74c54 | 2015-06-22 16:17:08 +0900 | [diff] [blame] | 104 | |
| 105 | char cwd[PATH_MAX]; |
| 106 | if (!getcwd(cwd, PATH_MAX)) { |
| 107 | fprintf(stderr, "getcwd failed\n"); |
| 108 | CHECK(false); |
| 109 | } |
| 110 | bootstrap += StringPrintf("CURDIR:=%s\n", cwd); |
Shinichiro Hamaji | 645cca7 | 2015-09-24 17:04:21 +0900 | [diff] [blame] | 111 | Parse(Intern(bootstrap).str(), Loc("*bootstrap*", 0), stmts); |
Shinichiro Hamaji | 0e74c54 | 2015-06-22 16:17:08 +0900 | [diff] [blame] | 112 | } |
| 113 | |
Shinichiro Hamaji | c9b9e5e | 2016-02-18 18:18:54 +0900 | [diff] [blame] | 114 | static void SetVar(StringPiece l, VarOrigin origin) { |
Shinichiro Hamaji | 9db4cb8 | 2015-06-22 16:51:04 +0900 | [diff] [blame] | 115 | size_t found = l.find('='); |
| 116 | CHECK(found != string::npos); |
Shinichiro Hamaji | e799275 | 2015-06-29 18:38:35 +0900 | [diff] [blame] | 117 | Symbol lhs = Intern(l.substr(0, found)); |
Shinichiro Hamaji | 9db4cb8 | 2015-06-22 16:51:04 +0900 | [diff] [blame] | 118 | StringPiece rhs = l.substr(found + 1); |
Shinichiro Hamaji | c9b9e5e | 2016-02-18 18:18:54 +0900 | [diff] [blame] | 119 | lhs.SetGlobalVar( |
| 120 | new RecursiveVar(NewLiteral(rhs.data()), origin, rhs.data())); |
Shinichiro Hamaji | 9db4cb8 | 2015-06-22 16:51:04 +0900 | [diff] [blame] | 121 | } |
| 122 | |
| 123 | extern "C" char** environ; |
Shinichiro Hamaji | 9db4cb8 | 2015-06-22 16:51:04 +0900 | [diff] [blame] | 124 | |
Dan Willemsen | fcc71f8 | 2017-10-11 18:35:09 -0700 | [diff] [blame] | 125 | class SegfaultHandler { |
| 126 | public: |
| 127 | explicit SegfaultHandler(Evaluator* ev); |
| 128 | ~SegfaultHandler(); |
| 129 | |
| 130 | void handle(int, siginfo_t*, void*); |
| 131 | |
| 132 | private: |
| 133 | static SegfaultHandler* global_handler; |
| 134 | |
| 135 | void dumpstr(const char* s) const { |
| 136 | (void)write(STDERR_FILENO, s, strlen(s)); |
| 137 | } |
| 138 | void dumpint(int i) const { |
| 139 | char buf[11]; |
| 140 | char* ptr = buf + sizeof(buf) - 1; |
| 141 | |
| 142 | if (i < 0) { |
| 143 | i = -i; |
| 144 | dumpstr("-"); |
| 145 | } else if (i == 0) { |
| 146 | dumpstr("0"); |
| 147 | return; |
| 148 | } |
| 149 | |
| 150 | *ptr = '\0'; |
| 151 | while (ptr > buf && i > 0) { |
| 152 | *--ptr = '0' + (i % 10); |
| 153 | i = i / 10; |
| 154 | } |
| 155 | |
| 156 | dumpstr(ptr); |
| 157 | } |
| 158 | |
| 159 | Evaluator* ev_; |
| 160 | |
| 161 | struct sigaction orig_action_; |
| 162 | struct sigaction new_action_; |
| 163 | }; |
| 164 | |
| 165 | SegfaultHandler* SegfaultHandler::global_handler = nullptr; |
| 166 | |
| 167 | SegfaultHandler::SegfaultHandler(Evaluator* ev) : ev_(ev) { |
| 168 | CHECK(global_handler == nullptr); |
| 169 | global_handler = this; |
| 170 | |
| 171 | // Construct an alternate stack, so that we can handle stack overflows. |
| 172 | stack_t ss; |
| 173 | ss.ss_sp = malloc(SIGSTKSZ * 2); |
| 174 | CHECK(ss.ss_sp != nullptr); |
| 175 | ss.ss_size = SIGSTKSZ * 2; |
| 176 | ss.ss_flags = 0; |
| 177 | if (sigaltstack(&ss, nullptr) == -1) { |
| 178 | PERROR("sigaltstack"); |
| 179 | } |
| 180 | |
| 181 | // Register our segfault handler using the alternate stack, falling |
| 182 | // back to the default handler. |
| 183 | sigemptyset(&new_action_.sa_mask); |
| 184 | new_action_.sa_flags = SA_ONSTACK | SA_SIGINFO | SA_RESETHAND; |
| 185 | new_action_.sa_sigaction = [](int sig, siginfo_t* info, void* context) { |
| 186 | if (global_handler != nullptr) { |
| 187 | global_handler->handle(sig, info, context); |
| 188 | } |
| 189 | |
| 190 | raise(SIGSEGV); |
| 191 | }; |
| 192 | sigaction(SIGSEGV, &new_action_, &orig_action_); |
| 193 | } |
| 194 | |
| 195 | void SegfaultHandler::handle(int sig, siginfo_t* info, void* context) { |
| 196 | // Avoid fprintf in case it allocates or tries to do anything else that may |
| 197 | // hang. |
| 198 | dumpstr("*kati*: Segmentation fault, last evaluated line was "); |
| 199 | dumpstr(ev_->loc().filename); |
| 200 | dumpstr(":"); |
| 201 | dumpint(ev_->loc().lineno); |
| 202 | dumpstr("\n"); |
| 203 | |
| 204 | // Run the original handler, in case we've been preloaded with libSegFault |
| 205 | // or similar. |
| 206 | if (orig_action_.sa_sigaction != nullptr) { |
| 207 | orig_action_.sa_sigaction(sig, info, context); |
| 208 | } |
| 209 | } |
| 210 | |
| 211 | SegfaultHandler::~SegfaultHandler() { |
| 212 | sigaction(SIGSEGV, &orig_action_, nullptr); |
| 213 | global_handler = nullptr; |
| 214 | } |
| 215 | |
Shinichiro Hamaji | e799275 | 2015-06-29 18:38:35 +0900 | [diff] [blame] | 216 | static int Run(const vector<Symbol>& targets, |
Shinichiro Hamaji | 998ccf7 | 2015-07-18 12:37:02 +0900 | [diff] [blame] | 217 | const vector<StringPiece>& cl_vars, |
| 218 | const string& orig_args) { |
Shinichiro Hamaji | 90db541 | 2015-08-13 15:03:52 +0900 | [diff] [blame] | 219 | double start_time = GetTime(); |
| 220 | |
Shinichiro Hamaji | 003d06e | 2015-09-09 18:22:04 +0900 | [diff] [blame] | 221 | if (g_flags.generate_ninja && (g_flags.regen || g_flags.dump_kati_stamp)) { |
Shinichiro Hamaji | f9e1524 | 2015-07-31 12:50:06 +0900 | [diff] [blame] | 222 | ScopedTimeReporter tr("regen check time"); |
Shinichiro Hamaji | f9869fc | 2015-09-28 17:18:59 +0900 | [diff] [blame] | 223 | if (!NeedsRegen(start_time, orig_args)) { |
Shinichiro Hamaji | ac50ff4 | 2016-02-09 16:23:28 +0900 | [diff] [blame] | 224 | fprintf(stderr, "No need to regenerate ninja file\n"); |
Shinichiro Hamaji | f6df334 | 2015-08-11 14:59:36 +0900 | [diff] [blame] | 225 | return 0; |
| 226 | } |
Shinichiro Hamaji | 003d06e | 2015-09-09 18:22:04 +0900 | [diff] [blame] | 227 | if (g_flags.dump_kati_stamp) { |
Shinichiro Hamaji | f6df334 | 2015-08-11 14:59:36 +0900 | [diff] [blame] | 228 | printf("Need to regenerate ninja file\n"); |
Shinichiro Hamaji | a4bb774 | 2015-07-31 11:27:30 +0900 | [diff] [blame] | 229 | return 0; |
| 230 | } |
Shinichiro Hamaji | a09ed28 | 2015-07-31 12:21:54 +0900 | [diff] [blame] | 231 | ClearGlobCache(); |
Shinichiro Hamaji | a4bb774 | 2015-07-31 11:27:30 +0900 | [diff] [blame] | 232 | } |
| 233 | |
Shinichiro Hamaji | 1a444a8 | 2016-02-16 13:49:49 +0900 | [diff] [blame] | 234 | SetAffinityForSingleThread(); |
| 235 | |
Shinichiro Hamaji | 776ca30 | 2015-06-06 03:52:48 +0900 | [diff] [blame] | 236 | MakefileCacheManager* cache_mgr = NewMakefileCacheManager(); |
Shinichiro Hamaji | 776ca30 | 2015-06-06 03:52:48 +0900 | [diff] [blame] | 237 | |
Dan Willemsen | 3ce083f | 2017-10-11 22:17:48 -0700 | [diff] [blame] | 238 | Intern("MAKEFILE_LIST") |
| 239 | .SetGlobalVar(new SimpleVar(StringPrintf(" %s", g_flags.makefile), |
| 240 | VarOrigin::FILE)); |
Shinichiro Hamaji | 91d1249 | 2015-09-04 09:54:48 +0900 | [diff] [blame] | 241 | for (char** p = environ; *p; p++) { |
Shinichiro Hamaji | c9b9e5e | 2016-02-18 18:18:54 +0900 | [diff] [blame] | 242 | SetVar(*p, VarOrigin::ENVIRONMENT); |
Shinichiro Hamaji | 91d1249 | 2015-09-04 09:54:48 +0900 | [diff] [blame] | 243 | } |
Dan Willemsen | fcc71f8 | 2017-10-11 18:35:09 -0700 | [diff] [blame] | 244 | unique_ptr<Evaluator> ev(new Evaluator()); |
| 245 | SegfaultHandler segfault(ev.get()); |
Shinichiro Hamaji | 0e74c54 | 2015-06-22 16:17:08 +0900 | [diff] [blame] | 246 | |
Shinichiro Hamaji | 645cca7 | 2015-09-24 17:04:21 +0900 | [diff] [blame] | 247 | vector<Stmt*> bootstrap_asts; |
Shinichiro Hamaji | 0e74c54 | 2015-06-22 16:17:08 +0900 | [diff] [blame] | 248 | ReadBootstrapMakefile(targets, &bootstrap_asts); |
| 249 | ev->set_is_bootstrap(true); |
Shinichiro Hamaji | 645cca7 | 2015-09-24 17:04:21 +0900 | [diff] [blame] | 250 | for (Stmt* stmt : bootstrap_asts) { |
| 251 | LOG("%s", stmt->DebugString().c_str()); |
Dan Willemsen | fcc71f8 | 2017-10-11 18:35:09 -0700 | [diff] [blame] | 252 | stmt->Eval(ev.get()); |
Shinichiro Hamaji | 0e74c54 | 2015-06-22 16:17:08 +0900 | [diff] [blame] | 253 | } |
| 254 | ev->set_is_bootstrap(false); |
| 255 | |
Shinichiro Hamaji | 1c3a695 | 2016-05-20 16:35:35 +0900 | [diff] [blame] | 256 | ev->set_is_commandline(true); |
Shinichiro Hamaji | 91d1249 | 2015-09-04 09:54:48 +0900 | [diff] [blame] | 257 | for (StringPiece l : cl_vars) { |
Shinichiro Hamaji | 1c3a695 | 2016-05-20 16:35:35 +0900 | [diff] [blame] | 258 | vector<Stmt*> asts; |
| 259 | Parse(Intern(l).str(), Loc("*bootstrap*", 0), &asts); |
| 260 | CHECK(asts.size() == 1); |
Dan Willemsen | fcc71f8 | 2017-10-11 18:35:09 -0700 | [diff] [blame] | 261 | asts[0]->Eval(ev.get()); |
Shinichiro Hamaji | 91d1249 | 2015-09-04 09:54:48 +0900 | [diff] [blame] | 262 | } |
Shinichiro Hamaji | 1c3a695 | 2016-05-20 16:35:35 +0900 | [diff] [blame] | 263 | ev->set_is_commandline(false); |
Shinichiro Hamaji | 91d1249 | 2015-09-04 09:54:48 +0900 | [diff] [blame] | 264 | |
Shinichiro Hamaji | 54e52dd | 2015-06-27 17:14:06 +0900 | [diff] [blame] | 265 | { |
| 266 | ScopedTimeReporter tr("eval time"); |
Shinichiro Hamaji | 003d06e | 2015-09-09 18:22:04 +0900 | [diff] [blame] | 267 | Makefile* mk = cache_mgr->ReadMakefile(g_flags.makefile); |
Shinichiro Hamaji | 645cca7 | 2015-09-24 17:04:21 +0900 | [diff] [blame] | 268 | for (Stmt* stmt : mk->stmts()) { |
| 269 | LOG("%s", stmt->DebugString().c_str()); |
Dan Willemsen | fcc71f8 | 2017-10-11 18:35:09 -0700 | [diff] [blame] | 270 | stmt->Eval(ev.get()); |
Shinichiro Hamaji | 54e52dd | 2015-06-27 17:14:06 +0900 | [diff] [blame] | 271 | } |
Shinichiro Hamaji | 776ca30 | 2015-06-06 03:52:48 +0900 | [diff] [blame] | 272 | } |
| 273 | |
Shinichiro Hamaji | 645cca7 | 2015-09-24 17:04:21 +0900 | [diff] [blame] | 274 | for (ParseErrorStmt* err : GetParseErrors()) { |
Dan Willemsen | e41c755 | 2017-02-22 14:31:16 -0800 | [diff] [blame] | 275 | WARN_LOC(err->loc(), "warning for parse error in an unevaluated line: %s", |
| 276 | err->msg.c_str()); |
Shinichiro Hamaji | a06bee9 | 2015-08-05 17:13:05 +0900 | [diff] [blame] | 277 | } |
| 278 | |
Shinichiro Hamaji | 776ca30 | 2015-06-06 03:52:48 +0900 | [diff] [blame] | 279 | vector<DepNode*> nodes; |
Shinichiro Hamaji | 54e52dd | 2015-06-27 17:14:06 +0900 | [diff] [blame] | 280 | { |
| 281 | ScopedTimeReporter tr("make dep time"); |
Dan Willemsen | fcc71f8 | 2017-10-11 18:35:09 -0700 | [diff] [blame] | 282 | MakeDep(ev.get(), ev->rules(), ev->rule_vars(), targets, &nodes); |
Shinichiro Hamaji | 54e52dd | 2015-06-27 17:14:06 +0900 | [diff] [blame] | 283 | } |
Shinichiro Hamaji | 776ca30 | 2015-06-06 03:52:48 +0900 | [diff] [blame] | 284 | |
Shinichiro Hamaji | 003d06e | 2015-09-09 18:22:04 +0900 | [diff] [blame] | 285 | if (g_flags.is_syntax_check_only) |
Shinichiro Hamaji | ed883ef | 2015-07-31 13:15:04 +0900 | [diff] [blame] | 286 | return 0; |
| 287 | |
Shinichiro Hamaji | 003d06e | 2015-09-09 18:22:04 +0900 | [diff] [blame] | 288 | if (g_flags.generate_ninja) { |
Shinichiro Hamaji | ed883ef | 2015-07-31 13:15:04 +0900 | [diff] [blame] | 289 | ScopedTimeReporter tr("generate ninja time"); |
Dan Willemsen | fcc71f8 | 2017-10-11 18:35:09 -0700 | [diff] [blame] | 290 | GenerateNinja(nodes, ev.get(), orig_args, start_time); |
Dan Willemsen | 36e5729 | 2017-10-09 11:23:32 -0700 | [diff] [blame] | 291 | ev->DumpStackStats(); |
Shinichiro Hamaji | ed883ef | 2015-07-31 13:15:04 +0900 | [diff] [blame] | 292 | return 0; |
| 293 | } |
| 294 | |
Shinichiro Hamaji | 45a0c76 | 2015-06-26 06:47:10 +0900 | [diff] [blame] | 295 | for (const auto& p : ev->exports()) { |
Shinichiro Hamaji | e799275 | 2015-06-29 18:38:35 +0900 | [diff] [blame] | 296 | const Symbol name = p.first; |
Shinichiro Hamaji | 45a0c76 | 2015-06-26 06:47:10 +0900 | [diff] [blame] | 297 | if (p.second) { |
| 298 | Var* v = ev->LookupVar(name); |
Dan Willemsen | fcc71f8 | 2017-10-11 18:35:09 -0700 | [diff] [blame] | 299 | const string&& value = v->Eval(ev.get()); |
Shinichiro Hamaji | fb415ad | 2015-08-14 17:19:34 +0900 | [diff] [blame] | 300 | LOG("setenv(%s, %s)", name.c_str(), value.c_str()); |
| 301 | setenv(name.c_str(), value.c_str(), 1); |
Shinichiro Hamaji | 45a0c76 | 2015-06-26 06:47:10 +0900 | [diff] [blame] | 302 | } else { |
| 303 | LOG("unsetenv(%s)", name.c_str()); |
| 304 | unsetenv(name.c_str()); |
| 305 | } |
| 306 | } |
| 307 | |
Shinichiro Hamaji | 54e52dd | 2015-06-27 17:14:06 +0900 | [diff] [blame] | 308 | { |
| 309 | ScopedTimeReporter tr("exec time"); |
Dan Willemsen | fcc71f8 | 2017-10-11 18:35:09 -0700 | [diff] [blame] | 310 | Exec(nodes, ev.get()); |
Shinichiro Hamaji | 54e52dd | 2015-06-27 17:14:06 +0900 | [diff] [blame] | 311 | } |
Shinichiro Hamaji | 776ca30 | 2015-06-06 03:52:48 +0900 | [diff] [blame] | 312 | |
Dan Willemsen | 36e5729 | 2017-10-09 11:23:32 -0700 | [diff] [blame] | 313 | ev->DumpStackStats(); |
| 314 | |
Shinichiro Hamaji | 645cca7 | 2015-09-24 17:04:21 +0900 | [diff] [blame] | 315 | for (Stmt* stmt : bootstrap_asts) |
| 316 | delete stmt; |
Shinichiro Hamaji | 776ca30 | 2015-06-06 03:52:48 +0900 | [diff] [blame] | 317 | delete cache_mgr; |
| 318 | |
Shinichiro Hamaji | 64cd806 | 2015-06-27 16:58:36 +0900 | [diff] [blame] | 319 | return 0; |
Shinichiro Hamaji | 776ca30 | 2015-06-06 03:52:48 +0900 | [diff] [blame] | 320 | } |
| 321 | |
Shinichiro Hamaji | 34556cc | 2015-10-05 15:01:46 +0900 | [diff] [blame] | 322 | static void FindFirstMakefie() { |
| 323 | if (g_flags.makefile != NULL) |
| 324 | return; |
| 325 | if (Exists("GNUmakefile")) { |
| 326 | g_flags.makefile = "GNUmakefile"; |
| 327 | #if !defined(__APPLE__) |
| 328 | } else if (Exists("makefile")) { |
| 329 | g_flags.makefile = "makefile"; |
| 330 | #endif |
| 331 | } else if (Exists("Makefile")) { |
| 332 | g_flags.makefile = "Makefile"; |
| 333 | } |
| 334 | } |
| 335 | |
Shinichiro Hamaji | 71cf60b | 2015-10-08 18:00:07 +0900 | [diff] [blame] | 336 | static void HandleRealpath(int argc, char** argv) { |
| 337 | char buf[PATH_MAX]; |
| 338 | for (int i = 0; i < argc; i++) { |
| 339 | if (realpath(argv[i], buf)) |
| 340 | printf("%s\n", buf); |
| 341 | } |
| 342 | } |
| 343 | |
Shinichiro Hamaji | 776ca30 | 2015-06-06 03:52:48 +0900 | [diff] [blame] | 344 | int main(int argc, char* argv[]) { |
Shinichiro Hamaji | 71cf60b | 2015-10-08 18:00:07 +0900 | [diff] [blame] | 345 | if (argc >= 2 && !strcmp(argv[1], "--realpath")) { |
| 346 | HandleRealpath(argc - 2, argv + 2); |
| 347 | return 0; |
| 348 | } |
Shinichiro Hamaji | 776ca30 | 2015-06-06 03:52:48 +0900 | [diff] [blame] | 349 | Init(); |
Shinichiro Hamaji | 998ccf7 | 2015-07-18 12:37:02 +0900 | [diff] [blame] | 350 | string orig_args; |
| 351 | for (int i = 0; i < argc; i++) { |
| 352 | if (i) |
| 353 | orig_args += ' '; |
| 354 | orig_args += argv[i]; |
| 355 | } |
Shinichiro Hamaji | 003d06e | 2015-09-09 18:22:04 +0900 | [diff] [blame] | 356 | g_flags.Parse(argc, argv); |
Shinichiro Hamaji | 34556cc | 2015-10-05 15:01:46 +0900 | [diff] [blame] | 357 | FindFirstMakefie(); |
Shinichiro Hamaji | 003d06e | 2015-09-09 18:22:04 +0900 | [diff] [blame] | 358 | if (g_flags.makefile == NULL) |
Shinichiro Hamaji | e4ee8ea | 2015-08-15 01:22:23 +0900 | [diff] [blame] | 359 | ERROR("*** No targets specified and no makefile found."); |
Shinichiro Hamaji | 5f57a99 | 2015-06-30 19:39:39 +0900 | [diff] [blame] | 360 | // This depends on command line flags. |
Shinichiro Hamaji | 003d06e | 2015-09-09 18:22:04 +0900 | [diff] [blame] | 361 | if (g_flags.use_find_emulator) |
Shinichiro Hamaji | 4e950e6 | 2015-07-02 02:59:55 +0900 | [diff] [blame] | 362 | InitFindEmulator(); |
Shinichiro Hamaji | 003d06e | 2015-09-09 18:22:04 +0900 | [diff] [blame] | 363 | int r = Run(g_flags.targets, g_flags.cl_vars, orig_args); |
Shinichiro Hamaji | 776ca30 | 2015-06-06 03:52:48 +0900 | [diff] [blame] | 364 | Quit(); |
| 365 | return r; |
| 366 | } |