Make the clang plugin look for path components.

tools/clang/plugins/ChromeClassTester.cpp

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // A general interface for filtering and only acting on classes in Chromium C++
 // code.
 
 #include "ChromeClassTester.h"
 
+#include <sys/param.h>
+
 using namespace clang;
 
 namespace {
 
 bool starts_with(const std::string& one, const std::string& two) {
   return one.substr(0, two.size()) == two;
 }
 
 bool ends_with(const std::string& one, const std::string& two) {
   if (two.size() > one.size())
     return false;
 
   return one.substr(one.size() - two.size(), two.size()) == two;
 }
 
 }  // namespace
 
 ChromeClassTester::ChromeClassTester(CompilerInstance& instance)
     : instance_(instance),
       diagnostic_(instance.getDiagnostics()) {
+  FigureOutSrcRoot();
+  BuildBannedLists();
+}
+
+void ChromeClassTester::FigureOutSrcRoot() {
+  char c_cwd[MAXPATHLEN];
+  if (getcwd(c_cwd, MAXPATHLEN) > 0) {
+    size_t pos = 1;
+    std::string cwd = c_cwd;
+
+    // Add a trailing '/' because the search below requires it.
+    if (cwd[cwd.size() - 1] != '/')
+      cwd += '/';
+
+    // Search the directory tree downwards until we find a path that contains
+    // "build/common.gypi" and assume that that is our srcroot.
+    size_t next_slash = cwd.find('/', pos);
+    while (next_slash != std::string::npos) {
+      next_slash++;
+      std::string candidate = cwd.substr(0, next_slash);
+      std::string common = candidate + "build/common.gypi";
+
+      if (access(common.c_str(), F_OK) != -1) {

[Nico, 2011/02/25 02:08:41]

you can save quite a few stats here if you only check this if common ends with
"src"

+        srcroot_ = candidate;
+        break;
+      }
+
+      pos = next_slash;
+      next_slash = cwd.find('/', pos);
+    }
+  }
+
+  if (srcroot_.empty()) {
+    llvm::errs() << "WARNING: Can't figure out srcroot!\n";

[Nico, 2011/02/25 02:08:41]

emit an error?

+  }
+}
+
+void ChromeClassTester::BuildBannedLists() {
   banned_namespaces_.push_back("std");
   banned_namespaces_.push_back("__gnu_cxx");
 
   banned_directories_.push_back("third_party");
   banned_directories_.push_back("native_client");
   banned_directories_.push_back("breakpad");
   banned_directories_.push_back("courgette");
   banned_directories_.push_back("ppapi");
   banned_directories_.push_back("/usr");
   banned_directories_.push_back("testing");
@@ skipping 137 matching lines @@
       // Don't complain about these things in implementation files.
       if (ends_with(b, ".cc") || ends_with(b, ".cpp") || ends_with(b, ".mm")) {
         return true;
       }
 
       // Don't complain about autogenerated protobuf files.
       if (ends_with(b, ".pb.h")) {
         return true;
       }
 
-      // Strip out all preceding path garbage. Linux and mac builds have
-      // different path garbage, but after doing this, the path should be
-      // relative to the root of the source tree. (If we didn't require
-      // relative paths, we could have just used realpath().)
-      if (!b.empty() && b[0] != '/') {
-        size_t i = 0;
-        for (; i < b.size() && (b[i] == '.' || b[i] == '/'); ++i) {}
-        b = b.substr(i);
+      // We need to munge the paths so that they are relative to the repository
+      // srcroot. We first resolve the symlinktastic relative path and then
+      // remove our known srcroot from it if needed.
+      char resolvedPath[MAXPATHLEN];
+      if (realpath(b.c_str(), resolvedPath)) {
+        std::string resolved = resolvedPath;
+        if (starts_with(resolved, srcroot_)) {
+          b = resolved.substr(srcroot_.size());
+        }
       }
 
       for (std::vector<std::string>::const_iterator it =
                banned_directories_.begin();
            it != banned_directories_.end(); ++it) {
         if (starts_with(b, *it))
           return true;
       }
     }
   }
 
   return false;
 }
 
 bool ChromeClassTester::IsIgnoredType(const std::string& base_name) {
   for (std::vector<std::string>::const_iterator it =
            ignored_record_names_.begin();
        it != ignored_record_names_.end(); ++it) {
     if (base_name == *it)
       return true;
   }
 
   return false;
 }