From 4ee1cb54d77d902a0223ebde12dff3b3efec8a8d Mon Sep 17 00:00:00 2001 From: Scott Graham Date: Sat, 8 Nov 2014 23:01:23 -0800 Subject: fix order of args to CanonicalizePath --- src/build.cc | 4 ++-- src/canon_perftest.cc | 2 +- src/graph.cc | 6 +++--- src/includes_normalize-win32.cc | 2 +- src/manifest_parser.cc | 6 +++--- src/ninja.cc | 4 ++-- src/util.cc | 8 ++++---- src/util.h | 6 +++--- src/util_test.cc | 38 +++++++++++++++++++------------------- 9 files changed, 38 insertions(+), 38 deletions(-) diff --git a/src/build.cc b/src/build.cc index a5f5fe8..a346028 100644 --- a/src/build.cc +++ b/src/build.cc @@ -851,8 +851,8 @@ bool Builder::ExtractDeps(CommandRunner::Result* result, for (vector::iterator i = deps.ins_.begin(); i != deps.ins_.end(); ++i) { unsigned int slash_bits; - if (!CanonicalizePath(const_cast(i->str_), &i->len_, err, - &slash_bits)) + if (!CanonicalizePath(const_cast(i->str_), &i->len_, &slash_bits, + err)) return false; deps_nodes->push_back(state_->GetNode(*i, slash_bits)); } diff --git a/src/canon_perftest.cc b/src/canon_perftest.cc index 8defa91..389ac24 100644 --- a/src/canon_perftest.cc +++ b/src/canon_perftest.cc @@ -35,7 +35,7 @@ int main() { int64_t start = GetTimeMillis(); unsigned int slash_bits; for (int i = 0; i < kNumRepetitions; ++i) { - CanonicalizePath(buf, &len, &err, &slash_bits); + CanonicalizePath(buf, &len, &slash_bits, &err); } int delta = (int)(GetTimeMillis() - start); times.push_back(delta); diff --git a/src/graph.cc b/src/graph.cc index 8666f50..f85a1f6 100644 --- a/src/graph.cc +++ b/src/graph.cc @@ -393,7 +393,7 @@ bool ImplicitDepLoader::LoadDepFile(Edge* edge, const string& path, unsigned int unused; if (!CanonicalizePath(const_cast(depfile.out_.str_), - &depfile.out_.len_, err, &unused)) + &depfile.out_.len_, &unused, err)) return false; // Check that this depfile matches the edge's output. @@ -413,8 +413,8 @@ bool ImplicitDepLoader::LoadDepFile(Edge* edge, const string& path, for (vector::iterator i = depfile.ins_.begin(); i != depfile.ins_.end(); ++i, ++implicit_dep) { unsigned int slash_bits; - if (!CanonicalizePath(const_cast(i->str_), &i->len_, err, - &slash_bits)) + if (!CanonicalizePath(const_cast(i->str_), &i->len_, &slash_bits, + err)) return false; Node* node = state_->GetNode(*i, slash_bits); diff --git a/src/includes_normalize-win32.cc b/src/includes_normalize-win32.cc index 7ea2813..1e88a0a 100644 --- a/src/includes_normalize-win32.cc +++ b/src/includes_normalize-win32.cc @@ -101,7 +101,7 @@ string IncludesNormalize::Normalize(const string& input, strncpy(copy, input.c_str(), input.size() + 1); string err; unsigned int slash_bits; - if (!CanonicalizePath(copy, &len, &err, &slash_bits)) + if (!CanonicalizePath(copy, &len, &slash_bits, &err)) Warning("couldn't canonicalize '%s': %s\n", input.c_str(), err.c_str()); StringPiece partially_fixed(copy, len); diff --git a/src/manifest_parser.cc b/src/manifest_parser.cc index 16214f1..388b5bc 100644 --- a/src/manifest_parser.cc +++ b/src/manifest_parser.cc @@ -210,7 +210,7 @@ bool ManifestParser::ParseDefault(string* err) { string path = eval.Evaluate(env_); string path_err; unsigned int slash_bits; // Unused because this only does lookup. - if (!CanonicalizePath(&path, &path_err, &slash_bits)) + if (!CanonicalizePath(&path, &slash_bits, &path_err)) return lexer_.Error(path_err, err); if (!state_->AddDefault(path, &path_err)) return lexer_.Error(path_err, err); @@ -325,7 +325,7 @@ bool ManifestParser::ParseEdge(string* err) { string path = i->Evaluate(env); string path_err; unsigned int slash_bits; - if (!CanonicalizePath(&path, &path_err, &slash_bits)) + if (!CanonicalizePath(&path, &slash_bits, &path_err)) return lexer_.Error(path_err, err); state_->AddIn(edge, path, slash_bits); } @@ -333,7 +333,7 @@ bool ManifestParser::ParseEdge(string* err) { string path = i->Evaluate(env); string path_err; unsigned int slash_bits; - if (!CanonicalizePath(&path, &path_err, &slash_bits)) + if (!CanonicalizePath(&path, &slash_bits, &path_err)) return lexer_.Error(path_err, err); state_->AddOut(edge, path, slash_bits); } diff --git a/src/ninja.cc b/src/ninja.cc index 5831e26..27380c0 100644 --- a/src/ninja.cc +++ b/src/ninja.cc @@ -229,7 +229,7 @@ struct RealFileReader : public ManifestParser::FileReader { bool NinjaMain::RebuildManifest(const char* input_file, string* err) { string path = input_file; unsigned int slash_bits; // Unused because this path is only used for lookup. - if (!CanonicalizePath(&path, err, &slash_bits)) + if (!CanonicalizePath(&path, &slash_bits, err)) return false; Node* node = state_.LookupNode(path); if (!node) @@ -252,7 +252,7 @@ bool NinjaMain::RebuildManifest(const char* input_file, string* err) { Node* NinjaMain::CollectTarget(const char* cpath, string* err) { string path = cpath; unsigned int slash_bits; // Unused because this path is only used for lookup. - if (!CanonicalizePath(&path, err, &slash_bits)) + if (!CanonicalizePath(&path, &slash_bits, err)) return NULL; // Special syntax: "foo.cc^" means "the first output of foo.cc". diff --git a/src/util.cc b/src/util.cc index cccf59c..ed878d1 100644 --- a/src/util.cc +++ b/src/util.cc @@ -85,13 +85,13 @@ void Error(const char* msg, ...) { fprintf(stderr, "\n"); } -bool CanonicalizePath(string* path, string* err, unsigned int* slash_bits) { +bool CanonicalizePath(string* path, unsigned int* slash_bits, string* err) { METRIC_RECORD("canonicalize str"); size_t len = path->size(); char* str = 0; if (len > 0) str = &(*path)[0]; - if (!CanonicalizePath(str, &len, err, slash_bits)) + if (!CanonicalizePath(str, &len, slash_bits, err)) return false; path->resize(len); return true; @@ -108,8 +108,8 @@ unsigned int ShiftOverBit(int offset, unsigned int bits) { return (above >> 1) | below; } -bool CanonicalizePath(char* path, size_t* len, string* err, - unsigned int* slash_bits) { +bool CanonicalizePath(char* path, size_t* len, unsigned int* slash_bits, + string* err) { // WARNING: this function is performance-critical; please benchmark // any changes you make to it. METRIC_RECORD("canonicalize path"); diff --git a/src/util.h b/src/util.h index cb0de09..cbdc1a6 100644 --- a/src/util.h +++ b/src/util.h @@ -43,9 +43,9 @@ void Error(const char* msg, ...); /// Canonicalize a path like "foo/../bar.h" into just "bar.h". /// |slash_bits| has bits set starting from lowest for a backslash that was /// normalized to a forward slash. (only used on Windows) -bool CanonicalizePath(string* path, string* err, unsigned int* slash_bits); -bool CanonicalizePath(char* path, size_t* len, string* err, - unsigned int* slash_bits); +bool CanonicalizePath(string* path, unsigned int* slash_bits, string* err); +bool CanonicalizePath(char* path, size_t* len, unsigned int* slash_bits, + string* err); /// Appends |input| to |*result|, escaping according to the whims of either /// Bash, or Win32's CommandLineToArgvW(). diff --git a/src/util_test.cc b/src/util_test.cc index 82db6d2..8ec7a28 100644 --- a/src/util_test.cc +++ b/src/util_test.cc @@ -20,7 +20,7 @@ namespace { bool CanonicalizePath(string* path, string* err) { unsigned int unused; - return ::CanonicalizePath(path, err, &unused); + return ::CanonicalizePath(path, &unused, err); } } // namespace @@ -164,82 +164,82 @@ TEST(CanonicalizePath, SlashTracking) { unsigned int slash_bits; path = "foo.h"; err = ""; - EXPECT_TRUE(CanonicalizePath(&path, &err, &slash_bits)); + EXPECT_TRUE(CanonicalizePath(&path, &slash_bits, &err)); EXPECT_EQ("foo.h", path); EXPECT_EQ(0, slash_bits); path = "a\\foo.h"; - EXPECT_TRUE(CanonicalizePath(&path, &err, &slash_bits)); + EXPECT_TRUE(CanonicalizePath(&path, &slash_bits, &err)); EXPECT_EQ("a/foo.h", path); EXPECT_EQ(1, slash_bits); path = "a/bcd/efh\\foo.h"; - EXPECT_TRUE(CanonicalizePath(&path, &err, &slash_bits)); + EXPECT_TRUE(CanonicalizePath(&path, &slash_bits, &err)); EXPECT_EQ("a/bcd/efh/foo.h", path); EXPECT_EQ(4, slash_bits); path = "a\\bcd/efh\\foo.h"; - EXPECT_TRUE(CanonicalizePath(&path, &err, &slash_bits)); + EXPECT_TRUE(CanonicalizePath(&path, &slash_bits, &err)); EXPECT_EQ("a/bcd/efh/foo.h", path); EXPECT_EQ(5, slash_bits); path = "a\\bcd\\efh\\foo.h"; - EXPECT_TRUE(CanonicalizePath(&path, &err, &slash_bits)); + EXPECT_TRUE(CanonicalizePath(&path, &slash_bits, &err)); EXPECT_EQ("a/bcd/efh/foo.h", path); EXPECT_EQ(7, slash_bits); path = "a/bcd/efh/foo.h"; - EXPECT_TRUE(CanonicalizePath(&path, &err, &slash_bits)); + EXPECT_TRUE(CanonicalizePath(&path, &slash_bits, &err)); EXPECT_EQ("a/bcd/efh/foo.h", path); EXPECT_EQ(0, slash_bits); path = "a\\./efh\\foo.h"; - EXPECT_TRUE(CanonicalizePath(&path, &err, &slash_bits)); + EXPECT_TRUE(CanonicalizePath(&path, &slash_bits, &err)); EXPECT_EQ("a/efh/foo.h", path); EXPECT_EQ(3, slash_bits); path = "a\\../efh\\foo.h"; - EXPECT_TRUE(CanonicalizePath(&path, &err, &slash_bits)); + EXPECT_TRUE(CanonicalizePath(&path, &slash_bits, &err)); EXPECT_EQ("efh/foo.h", path); EXPECT_EQ(1, slash_bits); path = "a\\b\\c\\d\\e\\f\\g\\foo.h"; - EXPECT_TRUE(CanonicalizePath(&path, &err, &slash_bits)); + EXPECT_TRUE(CanonicalizePath(&path, &slash_bits, &err)); EXPECT_EQ("a/b/c/d/e/f/g/foo.h", path); EXPECT_EQ(127, slash_bits); path = "a\\b\\c\\..\\..\\..\\g\\foo.h"; - EXPECT_TRUE(CanonicalizePath(&path, &err, &slash_bits)); + EXPECT_TRUE(CanonicalizePath(&path, &slash_bits, &err)); EXPECT_EQ("g/foo.h", path); EXPECT_EQ(1, slash_bits); path = "a\\b/c\\../../..\\g\\foo.h"; - EXPECT_TRUE(CanonicalizePath(&path, &err, &slash_bits)); + EXPECT_TRUE(CanonicalizePath(&path, &slash_bits, &err)); EXPECT_EQ("g/foo.h", path); EXPECT_EQ(1, slash_bits); path = "a\\b/c\\./../..\\g\\foo.h"; - EXPECT_TRUE(CanonicalizePath(&path, &err, &slash_bits)); + EXPECT_TRUE(CanonicalizePath(&path, &slash_bits, &err)); EXPECT_EQ("a/g/foo.h", path); EXPECT_EQ(3, slash_bits); path = "a\\b/c\\./../..\\g/foo.h"; - EXPECT_TRUE(CanonicalizePath(&path, &err, &slash_bits)); + EXPECT_TRUE(CanonicalizePath(&path, &slash_bits, &err)); EXPECT_EQ("a/g/foo.h", path); EXPECT_EQ(1, slash_bits); path = "a\\\\\\foo.h"; - EXPECT_TRUE(CanonicalizePath(&path, &err, &slash_bits)); + EXPECT_TRUE(CanonicalizePath(&path, &slash_bits, &err)); EXPECT_EQ("a/foo.h", path); EXPECT_EQ(1, slash_bits); path = "a/\\\\foo.h"; - EXPECT_TRUE(CanonicalizePath(&path, &err, &slash_bits)); + EXPECT_TRUE(CanonicalizePath(&path, &slash_bits, &err)); EXPECT_EQ("a/foo.h", path); EXPECT_EQ(0, slash_bits); path = "a\\//foo.h"; - EXPECT_TRUE(CanonicalizePath(&path, &err, &slash_bits)); + EXPECT_TRUE(CanonicalizePath(&path, &slash_bits, &err)); EXPECT_EQ("a/foo.h", path); EXPECT_EQ(1, slash_bits); } @@ -288,13 +288,13 @@ TEST(CanonicalizePath, NotNullTerminated) { path = "foo/. bar/."; len = strlen("foo/."); // Canonicalize only the part before the space. - EXPECT_TRUE(CanonicalizePath(&path[0], &len, &err, &unused)); + EXPECT_TRUE(CanonicalizePath(&path[0], &len, &unused, &err)); EXPECT_EQ(strlen("foo"), len); EXPECT_EQ("foo/. bar/.", string(path)); path = "foo/../file bar/."; len = strlen("foo/../file"); - EXPECT_TRUE(CanonicalizePath(&path[0], &len, &err, &unused)); + EXPECT_TRUE(CanonicalizePath(&path[0], &len, &unused, &err)); EXPECT_EQ(strlen("file"), len); EXPECT_EQ("file ./file bar/.", string(path)); } -- cgit v0.12