Merge remote-tracking branch 'aosp/upstream'HEADmaster

* aosp/upstream:
  Support git submodules in version.cc generation.
  Link ckati against jemalloc if host machine runs Linux.
  Support building in a git worktree
  Fix flaky test
  Switch to a golang-based test runner
  Refactor source tree into directories

Test: treehugger
Change-Id: I6cca6108531c4c32e3848bf6b532a99aef0f06c2

1 files changed, 0 insertions, 240 deletions

diff --git a/command.cc b/command.cc
deleted file mode 100644
index 04bb168..0000000
--- a/command.cc
+++ /dev/null
@@ -1,240 +0,0 @@
-// Copyright 2015 Google Inc. All rights reserved
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// +build ignore
-
-#include "command.h"
-
-#include <unordered_map>
-#include <unordered_set>
-
-#include "dep.h"
-#include "eval.h"
-#include "flags.h"
-#include "log.h"
-#include "strutil.h"
-#include "var.h"
-
-namespace {
-
-class AutoVar : public Var {
- public:
-  AutoVar() : Var(VarOrigin::AUTOMATIC) {}
-  virtual const char* Flavor() const override { return "undefined"; }
-
-  virtual void AppendVar(Evaluator*, Value*) override { CHECK(false); }
-
-  virtual StringPiece String() const override {
-    ERROR("$(value %s) is not implemented yet", sym_);
-    return "";
-  }
-
-  virtual string DebugString() const override {
-    return string("AutoVar(") + sym_ + ")";
-  }
-
- protected:
-  AutoVar(CommandEvaluator* ce, const char* sym) : ce_(ce), sym_(sym) {}
-  virtual ~AutoVar() = default;
-
-  CommandEvaluator* ce_;
-  const char* sym_;
-};
-
-#define DECLARE_AUTO_VAR_CLASS(name)                                  \
-  class name : public AutoVar {                                       \
-   public:                                                            \
-    name(CommandEvaluator* ce, const char* sym) : AutoVar(ce, sym) {} \
-    virtual ~name() = default;                                        \
-    virtual void Eval(Evaluator* ev, string* s) const override;       \
-  }
-
-DECLARE_AUTO_VAR_CLASS(AutoAtVar);
-DECLARE_AUTO_VAR_CLASS(AutoLessVar);
-DECLARE_AUTO_VAR_CLASS(AutoHatVar);
-DECLARE_AUTO_VAR_CLASS(AutoPlusVar);
-DECLARE_AUTO_VAR_CLASS(AutoStarVar);
-DECLARE_AUTO_VAR_CLASS(AutoNotImplementedVar);
-
-class AutoSuffixDVar : public AutoVar {
- public:
-  AutoSuffixDVar(CommandEvaluator* ce, const char* sym, Var* wrapped)
-      : AutoVar(ce, sym), wrapped_(wrapped) {}
-  virtual ~AutoSuffixDVar() = default;
-  virtual void Eval(Evaluator* ev, string* s) const override;
-
- private:
-  Var* wrapped_;
-};
-
-class AutoSuffixFVar : public AutoVar {
- public:
-  AutoSuffixFVar(CommandEvaluator* ce, const char* sym, Var* wrapped)
-      : AutoVar(ce, sym), wrapped_(wrapped) {}
-  virtual ~AutoSuffixFVar() = default;
-  virtual void Eval(Evaluator* ev, string* s) const override;
-
- private:
-  Var* wrapped_;
-};
-
-void AutoAtVar::Eval(Evaluator*, string* s) const {
-  *s += ce_->current_dep_node()->output.str();
-}
-
-void AutoLessVar::Eval(Evaluator*, string* s) const {
-  auto& ai = ce_->current_dep_node()->actual_inputs;
-  if (!ai.empty())
-    *s += ai[0].str();
-}
-
-void AutoHatVar::Eval(Evaluator*, string* s) const {
-  unordered_set<StringPiece> seen;
-  WordWriter ww(s);
-  for (Symbol ai : ce_->current_dep_node()->actual_inputs) {
-    if (seen.insert(ai.str()).second)
-      ww.Write(ai.str());
-  }
-}
-
-void AutoPlusVar::Eval(Evaluator*, string* s) const {
-  WordWriter ww(s);
-  for (Symbol ai : ce_->current_dep_node()->actual_inputs) {
-    ww.Write(ai.str());
-  }
-}
-
-void AutoStarVar::Eval(Evaluator*, string* s) const {
-  const DepNode* n = ce_->current_dep_node();
-  if (!n->output_pattern.IsValid())
-    return;
-  Pattern pat(n->output_pattern.str());
-  pat.Stem(n->output.str()).AppendToString(s);
-}
-
-void AutoNotImplementedVar::Eval(Evaluator* ev, string*) const {
-  ev->Error(StringPrintf("Automatic variable `$%s' isn't supported yet", sym_));
-}
-
-void AutoSuffixDVar::Eval(Evaluator* ev, string* s) const {
-  string buf;
-  wrapped_->Eval(ev, &buf);
-  WordWriter ww(s);
-  for (StringPiece tok : WordScanner(buf)) {
-    ww.Write(Dirname(tok));
-  }
-}
-
-void AutoSuffixFVar::Eval(Evaluator* ev, string* s) const {
-  string buf;
-  wrapped_->Eval(ev, &buf);
-  WordWriter ww(s);
-  for (StringPiece tok : WordScanner(buf)) {
-    ww.Write(Basename(tok));
-  }
-}
-
-void ParseCommandPrefixes(StringPiece* s, bool* echo, bool* ignore_error) {
-  *s = TrimLeftSpace(*s);
-  while (true) {
-    char c = s->get(0);
-    if (c == '@') {
-      *echo = false;
-    } else if (c == '-') {
-      *ignore_error = true;
-    } else if (c == '+') {
-      // ignore recursion marker
-    } else {
-      break;
-    }
-    *s = TrimLeftSpace(s->substr(1));
-  }
-}
-
-}  // namespace
-
-CommandEvaluator::CommandEvaluator(Evaluator* ev) : ev_(ev) {
-#define INSERT_AUTO_VAR(name, sym)                                      \
-  do {                                                                  \
-    Var* v = new name(this, sym);                                       \
-    Intern(sym).SetGlobalVar(v);                                        \
-    Intern(sym "D").SetGlobalVar(new AutoSuffixDVar(this, sym "D", v)); \
-    Intern(sym "F").SetGlobalVar(new AutoSuffixFVar(this, sym "F", v)); \
-  } while (0)
-  INSERT_AUTO_VAR(AutoAtVar, "@");
-  INSERT_AUTO_VAR(AutoLessVar, "<");
-  INSERT_AUTO_VAR(AutoHatVar, "^");
-  INSERT_AUTO_VAR(AutoPlusVar, "+");
-  INSERT_AUTO_VAR(AutoStarVar, "*");
-  // TODO: Implement them.
-  INSERT_AUTO_VAR(AutoNotImplementedVar, "%");
-  INSERT_AUTO_VAR(AutoNotImplementedVar, "?");
-  INSERT_AUTO_VAR(AutoNotImplementedVar, "|");
-}
-
-void CommandEvaluator::Eval(DepNode* n, vector<Command*>* commands) {
-  ev_->set_loc(n->loc);
-  ev_->set_current_scope(n->rule_vars);
-  current_dep_node_ = n;
-  for (Value* v : n->cmds) {
-    const string&& cmds_buf = v->Eval(ev_);
-    StringPiece cmds = cmds_buf;
-    bool global_echo = !g_flags.is_silent_mode;
-    bool global_ignore_error = false;
-    ParseCommandPrefixes(&cmds, &global_echo, &global_ignore_error);
-    if (cmds == "")
-      continue;
-    while (true) {
-      size_t lf_cnt;
-      size_t index = FindEndOfLine(cmds, 0, &lf_cnt);
-      if (index == cmds.size())
-        index = string::npos;
-      StringPiece cmd = TrimLeftSpace(cmds.substr(0, index));
-      cmds = cmds.substr(index + 1);
-
-      bool echo = global_echo;
-      bool ignore_error = global_ignore_error;
-      ParseCommandPrefixes(&cmd, &echo, &ignore_error);
-
-      if (!cmd.empty()) {
-        Command* command = new Command(n->output);
-        command->cmd = cmd.as_string();
-        command->echo = echo;
-        command->ignore_error = ignore_error;
-        commands->push_back(command);
-      }
-      if (index == string::npos)
-        break;
-    }
-    continue;
-  }
-
-  if (!ev_->delayed_output_commands().empty()) {
-    vector<Command*> output_commands;
-    for (const string& cmd : ev_->delayed_output_commands()) {
-      Command* c = new Command(n->output);
-      c->cmd = cmd;
-      c->echo = false;
-      c->ignore_error = false;
-      output_commands.push_back(c);
-    }
-    // Prepend |output_commands|.
-    commands->swap(output_commands);
-    copy(output_commands.begin(), output_commands.end(),
-         back_inserter(*commands));
-    ev_->clear_delayed_output_commands();
-  }
-
-  ev_->set_current_scope(NULL);
-}