7 files changed, 148 insertions, 11 deletions
diff --git a/src/parser_perftest.cc b/src/depfile_parser_perftest.cc
index b215221..b215221 100644
--- a/src/parser_perftest.cc
+++ b/src/depfile_parser_perftest.cc
diff --git a/src/disk_interface.cc b/src/disk_interface.cc
index 3233144..4dfae1a 100644
--- a/src/disk_interface.cc
+++ b/src/disk_interface.cc
@@ -14,6 +14,8 @@
 
 #include "disk_interface.h"
 
+#include <algorithm>
+
 #include <errno.h>
 #include <stdio.h>
 #include <string.h>
@@ -31,15 +33,16 @@ namespace {
 
 string DirName(const string& path) {
 #ifdef _WIN32
-  const char kPathSeparator = '\\';
+  const char kPathSeparators[] = "\\/";
 #else
-  const char kPathSeparator = '/';
+  const char kPathSeparators[] = "/";
 #endif
-
-  string::size_type slash_pos = path.rfind(kPathSeparator);
+  string::size_type slash_pos = path.find_last_of(kPathSeparators);
   if (slash_pos == string::npos)
     return string();  // Nothing to do.
-  while (slash_pos > 0 && path[slash_pos - 1] == kPathSeparator)
+  const char* const kEnd = kPathSeparators + strlen(kPathSeparators);
+  while (slash_pos > 0 &&
+         std::find(kPathSeparators, kEnd, path[slash_pos - 1]) != kEnd)
     --slash_pos;
   return path.substr(0, slash_pos);
 }
@@ -146,6 +149,9 @@ bool RealDiskInterface::WriteFile(const string& path, const string& contents) {
 
 bool RealDiskInterface::MakeDir(const string& path) {
   if (::MakeDir(path) < 0) {
+    if (errno == EEXIST) {
+      return true;
+    }
     Error("mkdir(%s): %s", path.c_str(), strerror(errno));
     return false;
   }
diff --git a/src/disk_interface_test.cc b/src/disk_interface_test.cc
index 55822a6..51a1d14 100644
--- a/src/disk_interface_test.cc
+++ b/src/disk_interface_test.cc
@@ -93,7 +93,18 @@ TEST_F(DiskInterfaceTest, ReadFile) {
 }
 
 TEST_F(DiskInterfaceTest, MakeDirs) {
-  EXPECT_TRUE(disk_.MakeDirs("path/with/double//slash/"));
+  string path = "path/with/double//slash/";
+  EXPECT_TRUE(disk_.MakeDirs(path.c_str()));
+  FILE* f = fopen((path + "a_file").c_str(), "w");
+  EXPECT_TRUE(f);
+  EXPECT_EQ(0, fclose(f));
+#ifdef _WIN32
+  string path2 = "another\\with\\back\\\\slashes\\";
+  EXPECT_TRUE(disk_.MakeDirs(path2.c_str()));
+  FILE* f2 = fopen((path2 + "a_file").c_str(), "w");
+  EXPECT_TRUE(f2);
+  EXPECT_EQ(0, fclose(f2));
+#endif
 }
 
 TEST_F(DiskInterfaceTest, RemoveFile) {
diff --git a/src/manifest_parser.cc b/src/manifest_parser.cc
index 17584dd..a566eda 100644
--- a/src/manifest_parser.cc
+++ b/src/manifest_parser.cc
@@ -296,16 +296,17 @@ bool ManifestParser::ParseEdge(string* err) {
   if (!ExpectToken(Lexer::NEWLINE, err))
     return false;
 
-  // XXX scoped_ptr to handle error case.
-  BindingEnv* env = new BindingEnv(env_);
-
-  while (lexer_.PeekToken(Lexer::INDENT)) {
+  // Bindings on edges are rare, so allocate per-edge envs only when needed.
+  bool hasIdent = lexer_.PeekToken(Lexer::INDENT);
+  BindingEnv* env = hasIdent ? new BindingEnv(env_) : env_;
+  while (hasIdent) {
     string key;
     EvalString val;
     if (!ParseLet(&key, &val, err))
       return false;
 
     env->AddBinding(key, val.Evaluate(env_));
+    hasIdent = lexer_.PeekToken(Lexer::INDENT);
   }
 
   Edge* edge = state_->AddEdge(rule);
diff --git a/src/manifest_parser_perftest.cc b/src/manifest_parser_perftest.cc
new file mode 100644
index 0000000..ed3a89a
--- /dev/null
+++ b/src/manifest_parser_perftest.cc
@@ -0,0 +1,112 @@
+// Copyright 2014 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.
+
+// Tests manifest parser performance.  Expects to be run in ninja's root
+// directory.
+
+#include <numeric>
+#include <stdio.h>
+
+#ifdef _WIN32
+#include <direct.h>
+#else
+#include <unistd.h>
+#endif
+
+#include "disk_interface.h"
+#include "graph.h"
+#include "manifest_parser.h"
+#include "metrics.h"
+#include "state.h"
+#include "util.h"
+
+struct RealFileReader : public ManifestParser::FileReader {
+  virtual bool ReadFile(const string& path, string* content, string* err) {
+    return ::ReadFile(path, content, err) == 0;
+  }
+};
+
+bool WriteFakeManifests(const string& dir) {
+  RealDiskInterface disk_interface;
+  if (disk_interface.Stat(dir + "/build.ninja") > 0)
+    return true;
+
+  printf("Creating manifest data..."); fflush(stdout);
+  int err = system(("python misc/write_fake_manifests.py " + dir).c_str());
+  printf("done.\n");
+  return err == 0;
+}
+
+int LoadManifests(bool measure_command_evaluation) {
+  string err;
+  RealFileReader file_reader;
+  State state;
+  ManifestParser parser(&state, &file_reader);
+  if (!parser.Load("build.ninja", &err)) {
+    fprintf(stderr, "Failed to read test data: %s\n", err.c_str());
+    exit(1);
+  }
+  // Doing an empty build involves reading the manifest and evaluating all
+  // commands required for the requested targets. So include command
+  // evaluation in the perftest by default.
+  int optimization_guard = 0;
+  if (measure_command_evaluation)
+    for (size_t i = 0; i < state.edges_.size(); ++i)
+      optimization_guard += state.edges_[i]->EvaluateCommand().size();
+  return optimization_guard;
+}
+
+int main(int argc, char* argv[]) {
+  bool measure_command_evaluation = true;
+  int opt;
+  while ((opt = getopt(argc, argv, const_cast<char*>("fh"))) != -1) {
+    switch (opt) {
+    case 'f':
+      measure_command_evaluation = false;
+      break;
+    case 'h':
+    default:
+      printf("usage: manifest_parser_perftest\n"
+"\n"
+"options:\n"
+"  -f     only measure manifest load time, not command evaluation time\n"
+             );
+    return 1;
+    }
+  }
+
+  const char kManifestDir[] = "build/manifest_perftest";
+
+  if (!WriteFakeManifests(kManifestDir)) {
+    fprintf(stderr, "Failed to write test data\n");
+    return 1;
+  }
+
+  chdir(kManifestDir);
+
+  const int kNumRepetitions = 5;
+  vector<int> times;
+  for (int i = 0; i < kNumRepetitions; ++i) {
+    int64_t start = GetTimeMillis();
+    int optimization_guard = LoadManifests(measure_command_evaluation);
+    int delta = (int)(GetTimeMillis() - start);
+    printf("%dms (hash: %x)\n", delta, optimization_guard);
+    times.push_back(delta);
+  }
+
+  int min = *min_element(times.begin(), times.end());
+  int max = *max_element(times.begin(), times.end());
+  float total = accumulate(times.begin(), times.end(), 0);
+  printf("min %dms  max %dms  avg %.1fms\n", min, max, total / times.size());
+}
diff --git a/src/msvc_helper-win32.cc b/src/msvc_helper-win32.cc
index d2e2eb5..e465279 100644
--- a/src/msvc_helper-win32.cc
+++ b/src/msvc_helper-win32.cc
@@ -141,7 +141,7 @@ int CLWrapper::Run(const string& command, string* output) {
   STARTUPINFO startup_info = {};
   startup_info.cb = sizeof(STARTUPINFO);
   startup_info.hStdInput = nul;
-  startup_info.hStdError = stdout_write;
+  startup_info.hStdError = ::GetStdHandle(STD_ERROR_HANDLE);
   startup_info.hStdOutput = stdout_write;
   startup_info.dwFlags |= STARTF_USESTDHANDLES;
 
diff --git a/src/msvc_helper_test.cc b/src/msvc_helper_test.cc
index 48fbe21..391c045 100644
--- a/src/msvc_helper_test.cc
+++ b/src/msvc_helper_test.cc
@@ -119,3 +119,10 @@ TEST(MSVCHelperTest, EnvBlock) {
   cl.Run("cmd /c \"echo foo is %foo%", &output);
   ASSERT_EQ("foo is bar\r\n", output);
 }
+
+TEST(MSVCHelperTest, NoReadOfStderr) {
+  CLWrapper cl;
+  string output;
+  cl.Run("cmd /c \"echo to stdout&& echo to stderr 1>&2", &output);
+  ASSERT_EQ("to stdout\r\n", output);
+}