Clang scripts updates.

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 96 matching lines @@
       edit_type, path, offset, length, replacement = line.split(':::', 4)
       replacement = replacement.replace('\0', '\n')
       # Normalize the file path emitted by the clang tool.
       path = os.path.realpath(os.path.join(build_directory, path))
       edits[path].append(Edit(edit_type, int(offset), int(length), replacement))
     except ValueError:
       print 'Unable to parse edit: %s' % line
   return edits
 
 
-def _ExecuteTool(toolname, build_directory, filename):
+def _ExecuteTool(toolname, tool_param, build_directory, filename):
   """Executes the tool.
 
   This is defined outside the class so it can be pickled for the multiprocessing
   module.
 
   Args:
     toolname: Path to the tool to execute.
+    tool_param: Parameter to be passed to the tool. Can be None.
     build_directory: Directory that contains the compile database.
     filename: The file to run the tool over.
 
   Returns:
     A dictionary that must contain the key "status" and a boolean value
     associated with it.
 
     If status is True, then the generated edits are stored with the key "edits"
     in the dictionary.
 
     Otherwise, the filename and the output from stderr are associated with the
     keys "filename" and "stderr" respectively.
   """
   command = subprocess.Popen(
-      (toolname, '-p', build_directory, filename),
+      (toolname, '-p', build_directory, filename) if tool_param is None else
+        (toolname, '-p', build_directory, filename, tool_param),
       stdout=subprocess.PIPE,
       stderr=subprocess.PIPE)
   stdout, stderr = command.communicate()
   if command.returncode != 0:
     return {'status': False, 'filename': filename, 'stderr': stderr}
   else:
     return {'status': True,
             'edits': _ExtractEditsFromStdout(build_directory, stdout)}
 
 
 class _CompilerDispatcher(object):
   """Multiprocessing controller for running clang tools in parallel."""
 
-  def __init__(self, toolname, build_directory, filenames):
+  def __init__(self, toolname, tool_param, build_directory, filenames):
     """Initializer method.
 
     Args:
       toolname: Path to the tool to execute.
+      tool_param: Parameter to be passed to the tool. Can be None.
       build_directory: Directory that contains the compile database.
       filenames: The files to run the tool over.
     """
     self.__toolname = toolname
+    self.__tool_param = tool_param
     self.__build_directory = build_directory
     self.__filenames = filenames
     self.__success_count = 0
     self.__failed_count = 0
     self.__edit_count = 0
     self.__edits = collections.defaultdict(list)
 
   @property
   def edits(self):
     return self.__edits
 
   @property
   def failed_count(self):
     return self.__failed_count
 
   def Run(self):
     """Does the grunt work."""
     pool = multiprocessing.Pool()
     result_iterator = pool.imap_unordered(
-        functools.partial(_ExecuteTool, self.__toolname,
-                          self.__build_directory), self.__filenames)
+        functools.partial(_ExecuteTool, self.__toolname, self.__tool_param,
+                          self.__build_directory),
+                          self.__filenames)
     for result in result_iterator:
       self.__ProcessResult(result)
     sys.stdout.write('\n')
     sys.stdout.flush()
 
   def __ProcessResult(self, result):
     """Handles result processing.
 
     Args:
       result: The result dictionary returned by _ExecuteTool.
@@ skipping 99 matching lines @@
       '--generate-compdb',
       action='store_true',
       help='regenerate the compile database before running the tool')
   parser.add_argument(
       'compile_database',
       help='path to the directory that contains the compile database')
   parser.add_argument(
       'path_filter',
       nargs='*',
       help='optional paths to filter what files the tool is run on')
+  parser.add_argument(
+      '--tool-param', type=str,

[dcheng, 2016/11/30 05:19:20]

Nit: the default is string already.

+      help='optional parameter passed to the tool')
   args = parser.parse_args()
 
   os.environ['PATH'] = '%s%s%s' % (
       os.path.abspath(os.path.join(
           os.path.dirname(__file__),
           '../../../third_party/llvm-build/Release+Asserts/bin')),
       os.pathsep,
       os.environ['PATH'])
 
   if args.generate_compdb:
     compile_db.GenerateWithNinja(args.compile_database)
 
   if args.all:
     filenames = set(_GetFilesFromCompileDB(args.compile_database))
     source_filenames = filenames
   else:
     filenames = set(_GetFilesFromGit(args.path_filter))
     # Filter out files that aren't C/C++/Obj-C/Obj-C++.
     extensions = frozenset(('.c', '.cc', '.cpp', '.m', '.mm'))
     source_filenames = [f
                         for f in filenames
                         if os.path.splitext(f)[1] in extensions]
-  dispatcher = _CompilerDispatcher(args.tool, args.compile_database,
+  dispatcher = _CompilerDispatcher(args.tool, args.tool_param,
+                                   args.compile_database,
                                    source_filenames)
   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 os.path.realpath(k) in filenames})
   return -dispatcher.failed_count
 
 
 if __name__ == '__main__':
-  sys.exit(main())
+  sys.exit(main())