add PRESUBMIT for native_client_sdk.

native_client_sdk/src/tools/create_nmf.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 from __future__ import with_statement
 
 import errno
 import optparse
 import os
@@ skipping 100 matching lines @@
 class NmfUtils(object):
   '''Helper class for creating and managing nmf files
 
   Attributes:
     manifest: A JSON-structured dict containing the nmf structure
     needed: A dict with key=filename and value=ArchFile (see GetNeeded)
   '''
 
   def __init__(self, main_files=None, objdump='x86_64-nacl-objdump',
                lib_path=None, extra_files=None, lib_prefix=None,
-               toolchain=None, remap={}):
+               toolchain=None, remap=None):
     '''Constructor
 
     Args:
       main_files: List of main entry program files.  These will be named
           files->main.nexe for dynamic nexes, and program for static nexes
       objdump: path to x86_64-nacl-objdump tool (or Linux equivalent)
       lib_path: List of paths to library directories
       extra_files: List of extra files to include in the nmf
       lib_prefix: A list of path components to prepend to the library paths,
           both for staging the libraries and for inclusion into the nmf file.
           Examples:  ['..'], ['lib_dir']
       toolchain: Specify which toolchain newlib|glibc|pnacl which can require
           different forms of the NMF.
       remap: Remaps the library name in the manifest.
       '''
     self.objdump = objdump
     self.main_files = main_files or []
     self.extra_files = extra_files or []
     self.lib_path = lib_path or []
     self.manifest = None
     self.needed = None
     self.lib_prefix = lib_prefix or []
     self.toolchain = toolchain
-    self.remap = remap
+    self.remap = remap or {}
 
 
   def GleanFromObjdump(self, files):
     '''Get architecture and dependency information for given files
 
     Args:
       files: A dict with key=filename and value=list or set of archs.  E.g.:
           { '/path/to/my.nexe': ['x86-32']
             '/path/to/lib64/libmy.so': ['x86-64'],
             '/path/to/mydata.so': ['x86-32', 'x86-64'],
@@ skipping 40 matching lines @@
 
   def FindLibsInPath(self, name):
     '''Finds the set of libraries matching |name| within lib_path
 
     Args:
       name: name of library to find
 
     Returns:
       A list of system paths that match the given name within the lib_path'''
     files = []
-    for dir in self.lib_path:
-      file = os.path.join(dir, name)
-      if os.path.exists(file):
-        files.append(file)
+    for dirname in self.lib_path:
+      filename = os.path.join(dirname, name)
+      if os.path.exists(filename):
+        files.append(filename)
     if not files:
       raise Error('cannot find library %s' % name)
     return files
 
   def GetNeeded(self):
     '''Collect the list of dependencies for the main_files
 
     Returns:
       A dict with key=filename and value=ArchFile of input files.
           Includes the input files as well, with arch filled in if absent.
           Example: { '/path/to/my.nexe': ArchFile(my.nexe),
                      '/path/to/libfoo.so': ArchFile(libfoo.so) }'''
     if self.needed:
       return self.needed
 
     runnable = (self.toolchain != 'newlib' and self.toolchain != 'pnacl')
     DebugPrint('GetNeeded(%s)' % self.main_files)
     if runnable:
       examined = set()
       all_files, unexamined = self.GleanFromObjdump(
-          dict([(file, None) for file in self.main_files]))
+          dict([(f, None) for f in self.main_files]))
       for name, arch_file in all_files.items():
         arch_file.url = name
         if unexamined:
           unexamined.add('/'.join([arch_file.arch, RUNNABLE_LD]))
       while unexamined:
         files_to_examine = {}
         for arch_name in unexamined:
           arch, name = arch_name.split('/')
           for path in self.FindLibsInPath(name):
             files_to_examine.setdefault(path, set()).add(arch)
@@ skipping 182 matching lines @@
   else:
     path_prefix = []
 
   nmf = NmfUtils(objdump=options.objdump,
                  main_files=args,
                  lib_path=options.lib_path,
                  lib_prefix=path_prefix,
                  toolchain=options.toolchain,
                  remap=remap)
 
-  manifest = nmf.GetManifest()
+  nmf.GetManifest()
   if options.output is None:
     sys.stdout.write(nmf.GetJson())
   else:
     with open(options.output, 'w') as output:
       output.write(nmf.GetJson())
 
   if options.stage_dependencies:
     Trace("Staging dependencies...")
     nmf.StageDependencies(options.stage_dependencies)
 
   return 0
 
 
 # Invoke this file directly for simple testing.
 if __name__ == '__main__':
   try:
     rtn = Main(sys.argv[1:])
   except Error, e:
     print "%s: %s" % (os.path.basename(__file__), e)
     rtn = 1
   sys.exit(rtn)