fix pylint warnings

native_client_sdk/src/build_tools/generate_make.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.
 
 import buildbot_common
-import make_rules
 import optparse
 import os
 import sys
-
 from make_rules import MakeRules, SetVar, GenerateCleanRules, GenerateNMFRules
 
 SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
 SDK_SRC_DIR = os.path.dirname(SCRIPT_DIR)
 SDK_EXAMPLE_DIR = os.path.join(SDK_SRC_DIR, 'examples')
 SDK_DIR = os.path.dirname(SDK_SRC_DIR)
 SRC_DIR = os.path.dirname(SDK_DIR)
 OUT_DIR = os.path.join(SRC_DIR, 'out')
 PPAPI_DIR = os.path.join(SRC_DIR, 'ppapi')
 
@@ skipping 56 matching lines @@
 
 
 def GetPlatforms(plat_list, plat_filter):
   platforms = []
   for plat in plat_list:
     if plat in plat_filter:
       platforms.append(plat)
   return platforms
 
 
-def GenerateToolDefaults(desc, tools):
+def GenerateToolDefaults(tools):
   defaults = ''
   for tool in tools:
     defaults += MakeRules(tool).BuildDefaults()
   return defaults
 
 
 def GenerateSettings(desc, tools):
   settings = SetVar('VALID_TOOLCHAINS', tools)
-  settings+= 'TOOLCHAIN?=%s\n\n' % tools[0]
+  settings += 'TOOLCHAIN?=%s\n\n' % tools[0]
   for target in desc['TARGETS']:
     project = target['NAME']
     macro = project.upper()
-    srcs = GetSourcesDict(target['SOURCES'])
 
     c_flags = target.get('CCFLAGS')
     cc_flags = target.get('CXXFLAGS')
     ld_flags = target.get('LDFLAGS')
 
     if c_flags:
       settings += SetVar(macro + '_CCFLAGS', c_flags)
     if cc_flags:
       settings += SetVar(macro + '_CXXFLAGS', cc_flags)
     if ld_flags:
       settings += SetVar(macro + '_LDFLAGS', ld_flags)
   return settings
 
 
 def GenerateRules(desc, tools):
-  all_targets = []
-  clean = []
   rules = '#\n# Per target object lists\n#\n'
 
   #Determine which projects are in the NMF files.
-  main = None
+  executable = None
   dlls = []
   project_list = []
   glibc_rename = []
 
   for target in desc['TARGETS']:
     ptype = target['TYPE'].upper()
     project = target['NAME']
     project_list.append(project)
     srcs = GetSourcesDict(target['SOURCES'])
     if ptype == 'MAIN':
-      main = project
+      executable = project
     if ptype == 'SO':
       dlls.append(project)
       for arch in ['x86_32', 'x86_64']:
         glibc_rename.append('-n %s_%s.so,%s.so' % (project, arch, project))
 
     objects = GetProjectObjects(srcs)
     rules += SetVar('%s_OBJS' % project.upper(), objects)
     if glibc_rename:
       rules += SetVar('GLIBC_REMAP', glibc_rename)
 
   configs = desc.get('CONFIGS', ['Debug', 'Release'])
   for tc in tools:
     makeobj = MakeRules(tc)
     arches = makeobj.GetArches()
     rules += makeobj.BuildDirectoryRules(configs)
     for cfg in configs:
       makeobj.SetConfig(cfg)
       for target in desc['TARGETS']:
         project = target['NAME']
         ptype = target['TYPE']
         srcs = GetSourcesDict(target['SOURCES'])
-        objs = GetProjectObjects(srcs)
         defs = target.get('DEFINES', [])
         incs = target.get('INCLUDES', [])
         libs = target.get('LIBS', [])
-        lpaths = target.get('LIBPATHS', [])
-        ipaths = target.get('INCPATHS', [])
         makeobj.SetProject(project, ptype, defs=defs, incs=incs, libs=libs)
-        if ptype == 'main':
-          rules += makeobj.GetPepperPlugin()
+        if ptype == 'main':
+          rules += makeobj.GetPepperPlugin()
         for arch in arches:
           makeobj.SetArch(arch)
           for src in srcs.get('.c', []):
             rules += makeobj.BuildCompileRule('CC', src)
           for src in srcs.get('.cc', []):
             rules += makeobj.BuildCompileRule('CXX', src)
           rules += '\n'
           rules += makeobj.BuildObjectList()
           rules += makeobj.BuildLinkRule()
-      if main:
-        rules += GenerateNMFRules(tc, main, dlls, cfg, arches)
+      if executable:
+        rules += GenerateNMFRules(tc, executable, dlls, cfg, arches)
 
   rules += GenerateCleanRules(tools, configs)
   rules += '\nall: $(ALL_TARGETS)\n'
 
   return '', rules
 
 
 
 def GenerateReplacements(desc, tools):
   # Generate target settings
-  plats = GetPlatforms(desc['TOOLS'], tools)
-
   settings = GenerateSettings(desc, tools)
-  tool_def = GenerateToolDefaults(desc, tools)
-  all_targets, rules = GenerateRules(desc, tools)
+  tool_def = GenerateToolDefaults(tools)
+  _, rules = GenerateRules(desc, tools)
 
   prelaunch = desc.get('LAUNCH', '')
   prerun = desc.get('PRE', '')
   postlaunch = desc.get('POST', '')
 
   target_def = 'all:'
 
   return {
       '__PROJECT_SETTINGS__' : settings,
       '__PROJECT_TARGETS__' : target_def,
@@ skipping 34 matching lines @@
     'DESC': (str, '', False),
     'INFO': (str, '', False),
     'EXPERIMENTAL': (bool, [True, False], False)
 }
 
 
 def ErrorMsgFunc(text):
   sys.stderr.write(text + '\n')
 
 
-def ValidateFormat(src, format, ErrorMsg=ErrorMsgFunc):
+def ValidateFormat(src, dsc_format, ErrorMsg=ErrorMsgFunc):
   failed = False
 
   # Verify all required keys are there
-  for key in format:
-    (exp_type, exp_value, required) = format[key]
+  for key in dsc_format:
+    (exp_type, exp_value, required) = dsc_format[key]
     if required and key not in src:
       ErrorMsg('Missing required key %s.' % key)
       failed = True
 
   # For each provided key, verify it's valid
   for key in src:
     # Verify the key is known
-    if key not in format:
+    if key not in dsc_format:
       ErrorMsg('Unexpected key %s.' % key)
       failed = True
       continue
 
-    exp_type, exp_value, required = format[key]
+    exp_type, exp_value, required = dsc_format[key]
     value = src[key]
 
     # Verify the key is of the expected type
     if exp_type != type(value):
       ErrorMsg('Key %s expects %s not %s.' % (
           key, exp_type.__name__.upper(), type(value).__name__.upper()))
       failed = True
       continue
 
     # Verify the value is non-empty if required
@@ skipping 163 matching lines @@
   sources = GenerateSourceCopyList(desc)
   FindAndCopyFiles(sources, srcroot, srcdirs, out_dir)
 
   # Copy public headers to the include directory.
   for headers_set in desc.get('HEADERS', []):
     headers = headers_set['FILES']
     header_out_dir = os.path.join(dstroot, headers_set['DEST'])
     FindAndCopyFiles(headers, srcroot, srcdirs, header_out_dir)
 
   if IsNexe(desc):
-    template=os.path.join(SCRIPT_DIR, 'template.mk')
+    template = os.path.join(SCRIPT_DIR, 'template.mk')
   else:
-    template=os.path.join(SCRIPT_DIR, 'library.mk')
+    template = os.path.join(SCRIPT_DIR, 'library.mk')
 
   tools = []
   for tool in desc['TOOLS']:
     if tool in toolchains:
       tools.append(tool)
 
   # Add Makefile and make.bat
   repdict = GenerateReplacements(desc, tools)
   make_path = os.path.join(out_dir, 'Makefile')
   WriteReplaced(template, make_path, repdict)
@@ skipping 79 matching lines @@
   if options.master:
     master_in = os.path.join(SDK_EXAMPLE_DIR, 'Makefile')
     for dest, projects in master_projects.iteritems():
       master_out = os.path.join(options.dstroot, dest, 'Makefile')
       GenerateMasterMakefile(master_in, master_out, projects)
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))