Various hacks for running a clang tool on Windows.

tools/clang/scripts/run_tool.py

 #!/usr/bin/env python
 # Copyright (c) 2013 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.
 
 """Wrapper script to help run clang tools across Chromium code.
 
 How to use this tool:
 If you want to run the tool across all Chromium code:
 run_tool.py <tool> <path/to/compiledb>
@@ skipping 36 matching lines @@
 Edit = collections.namedtuple(
     'Edit', ('edit_type', 'offset', 'length', 'replacement'))
 
 
 def _GetFilesFromGit(paths = None):
   """Gets the list of files in the git repository.
 
   Args:
     paths: Prefix filter for the returned paths. May contain multiple entries.
   """
-  args = ['git', 'ls-files']
+  args = ['git.bat', 'ls-files']

[dcheng, 2014/11/11 23:36:07]

Yay, Windows.

   if paths:
     args.extend(paths)
   command = subprocess.Popen(args, stdout=subprocess.PIPE)
   output, _ = command.communicate()
   return output.splitlines()
 
 
 def _ExtractEditsFromStdout(build_directory, stdout):
   """Extracts generated list of edits from the tool's stdout.
 
@@ skipping 65 matching lines @@
     Args:
       toolname: Path to the tool to execute.
       build_directory: Directory that contains the compile database.
       filenames: The files to run the tool over.
     """
     self.__toolname = toolname
     self.__build_directory = build_directory
     self.__filenames = filenames
     self.__success_count = 0
     self.__failed_count = 0
+    self.__edit_count = 0

[dcheng, 2014/11/11 23:36:07]

I'll probably upstream this elsewhere--it's always nice to know there's forward
progress.

[dcheng, 2014/11/11 23:36:07]

I'll probably upstream this elsewhere--it's always nice to know there's forward
progress.

     self.__edits = collections.defaultdict(list)
 
   @property
   def edits(self):
     return self.__edits
 
   @property
   def failed_count(self):
     return self.__failed_count
 
@@ skipping 12 matching lines @@
   def __ProcessResult(self, result):
     """Handles result processing.
 
     Args:
       result: The result dictionary returned by _ExecuteTool.
     """
     if result['status']:
       self.__success_count += 1
       for k, v in result['edits'].iteritems():
         self.__edits[k].extend(v)
+        self.__edit_count += len(v)
     else:
       self.__failed_count += 1
       sys.stdout.write('\nFailed to process %s\n' % result['filename'])
       sys.stdout.write(result['stderr'])
       sys.stdout.write('\n')
     percentage = (
         float(self.__success_count + self.__failed_count) /
         len(self.__filenames)) * 100
-    sys.stdout.write('Succeeded: %d, Failed: %d [%.2f%%]\r' % (
-        self.__success_count, self.__failed_count, percentage))
+    sys.stdout.write('Succeeded: %d, Failed: %d, Edits: %d [%.2f%%]\r' % (
+        self.__success_count, self.__failed_count, self.__edit_count,
+        percentage))
     sys.stdout.flush()
 
 
 def _ApplyEdits(edits, clang_format_diff_path):
   """Apply the generated edits.
 
   Args:
     edits: A dict mapping filenames to Edit instances that apply to that file.
     clang_format_diff_path: Path to the clang-format-diff.py helper to help
       automatically reformat diffs to avoid style violations. Pass None if the
@@ skipping 83 matching lines @@
     print '  <path 1> <path2> ... can be used to filter what files are edited'
     return 1
 
   clang_format_diff_path = os.path.join(
       os.path.dirname(os.path.realpath(__file__)),
       '../../../third_party/llvm/tools/clang/tools/clang-format',
       'clang-format-diff.py')
   # TODO(dcheng): Allow this to be controlled with a flag as well.
   if not os.path.isfile(clang_format_diff_path):
     clang_format_diff_path = None
+  clang_format_diff_path = None
 
   filenames = frozenset(_GetFilesFromGit(argv[2:]))
   # Filter out files that aren't C/C++/Obj-C/Obj-C++.
   extensions = frozenset(('.c', '.cc', '.m', '.mm'))
   dispatcher = _CompilerDispatcher(argv[0], argv[1],
                                    [f for f in filenames
                                     if os.path.splitext(f)[1] in extensions])
   dispatcher.Run()
   # Filter out edits to files that aren't in the git repository, since it's not
   # useful to modify files that aren't under source control--typically, these
   # are generated files or files in a git submodule that's not part of Chromium.
   _ApplyEdits({k : v for k, v in dispatcher.edits.iteritems()
                     if k in filenames},
               clang_format_diff_path)
   if dispatcher.failed_count != 0:
     return 2
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))