Build Tools Cleanup

tools/build.py

 #!/usr/bin/env python
 #
-# Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
+# Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 # for details. All rights reserved. Use of this source code is governed by a
 # BSD-style license that can be found in the LICENSE file.
 #
 
 import optparse
 import os
 import re
-import shutil
 import subprocess
 import sys
 import time
 import utils
 
 HOST_OS = utils.GuessOS()
 HOST_CPUS = utils.GuessCpus()
 SCRIPT_DIR = os.path.dirname(sys.argv[0])
 DART_ROOT = os.path.realpath(os.path.join(SCRIPT_DIR, '..'))
 THIRD_PARTY_ROOT = os.path.join(DART_ROOT, 'third_party')
@@ skipping 40 matching lines @@
   result.add_option("--devenv",
       help='Path containing devenv.com on Windows',
       default=vs_directory)
   result.add_option("--executable",
       help='Name of the devenv.com/msbuild executable on Windows (varies for '
            'different versions of Visual Studio)',
       default=vs_executable)
   return result
 
 
-def ProcessOsOption(os):
-  if os == 'host':
+def ProcessOsOption(os_name):
+  if os_name == 'host':
     return HOST_OS
-  return os
+  return os_name
 
 
 def ProcessOptions(options, args):
+  global arch

[ricow1, 2014/06/27 07:35:34]

I don't think we need this

   if options.arch == 'all':
     options.arch = 'ia32,x64,simarm,simmips,simarm64'
   if options.mode == 'all':
     options.mode = 'release,debug'
   if options.os == 'all':
     options.os = 'host,android'
   options.mode = options.mode.split(',')
   options.arch = options.arch.split(',')
   options.os = options.os.split(',')
   for mode in options.mode:
     if not mode in ['debug', 'release']:
       print "Unknown mode %s" % mode
       return False
   for arch in options.arch:
     archs = ['ia32', 'x64', 'simarm', 'arm', 'simmips', 'mips',
              'simarm64', 'arm64',]
     if not arch in archs:
       print "Unknown arch %s" % arch
       return False
-  options.os = [ProcessOsOption(os) for os in options.os]
-  for os in options.os:
-    if not os in ['android', 'freebsd', 'linux', 'macos', 'win32']:
-      print "Unknown os %s" % os
+  options.os = [ProcessOsOption(os_name) for os_name in options.os]
+  for os_name in options.os:
+    if not os_name in ['android', 'freebsd', 'linux', 'macos', 'win32']:
+      print "Unknown os %s" % os_name
       return False
-    if os != HOST_OS:
-      if os != 'android':
-        print "Unsupported target os %s" % os
+    if os_name != HOST_OS:
+      if os_name != 'android':
+        print "Unsupported target os %s" % os_name
         return False
       if not HOST_OS in ['linux']:
         print ("Cross-compilation to %s is not supported on host os %s."
-               % (os, HOST_OS))
+               % (os_name, HOST_OS))
         return False
       if not arch in ['ia32', 'arm', 'mips']:
         print ("Cross-compilation to %s is not supported for architecture %s."
-               % (os, arch))
+               % (os_name, arch))
         return False
       # We have not yet tweaked the v8 dart build to work with the Android
       # NDK/SDK, so don't try to build it.
-      if args == []:
+      if not args:
         print "For android builds you must specify a target, such as 'runtime'."
         return False
   return True
 
 
-def SetTools(arch, target_os, toolchainprefix):
+def SetTools(sys_arch, target_os, toolchainprefix):
   toolsOverride = None
 
   # For Android, by default use the toolchain from third_party/android_tools.
-  if target_os == 'android' and toolchainprefix == None:
-    android_toolchain = GetAndroidToolchainDir(HOST_OS, arch)
-    if arch == 'arm':
+  if target_os == 'android' and toolchainprefix is None:
+    android_toolchain = GetAndroidToolchainDir(HOST_OS, sys_arch)
+    if sys_arch == 'arm':
       toolchainprefix = os.path.join(
           android_toolchain, 'arm-linux-androideabi')
-    if arch == 'ia32':
+    if sys_arch == 'ia32':
       toolchainprefix = os.path.join(
           android_toolchain, 'i686-linux-android')
 
   # For ARM Linux, by default use the Linux distribution's cross-compiler.
-  if arch == 'arm' and toolchainprefix == None:
+  if sys_arch == 'arm' and toolchainprefix is None:
     # We specify the hf compiler. If this changes, we must also remove
     # the ARM_FLOAT_ABI_HARD define in configurations_make.gypi.
     toolchainprefix = (DEFAULT_ARM_CROSS_COMPILER_PATH +
                        "/arm-linux-gnueabihf")
 
   # TODO(zra): Find a default MIPS Linux cross-compiler?
 
   # Override the Android toolchain's linker to handle some complexity in the
   # linker arguments that gyp has trouble with.
   linker = ""
@@ skipping 20 matching lines @@
 
 
 def GetAndroidToolchainDir(host_os, target_arch):
   global THIRD_PARTY_ROOT
   if host_os not in ['linux']:
     raise Exception('Unsupported host os %s' % host_os)
   if target_arch not in ['ia32', 'arm']:
     raise Exception('Unsupported target architecture %s' % target_arch)
 
   # Set up path to the Android NDK.
-  CheckDirExists(THIRD_PARTY_ROOT, 'third party tools');
+  CheckDirExists(THIRD_PARTY_ROOT, 'third party tools')
   android_tools = os.path.join(THIRD_PARTY_ROOT, 'android_tools')
   CheckDirExists(android_tools, 'Android tools')
   android_ndk_root = os.path.join(android_tools, 'ndk')
   CheckDirExists(android_ndk_root, 'Android NDK')
 
   # Set up the directory of the Android NDK cross-compiler toolchain.
   toolchain_arch = 'arm-linux-androideabi-4.6'
   if target_arch == 'ia32':
     toolchain_arch = 'x86-4.6'
   toolchain_dir = 'linux-x86_64'
@@ skipping 36 matching lines @@
 
 PhaseScriptExecution "Action \"upload_sdk_py\"" xcodebuild/dart.build/...
     cd ...
     /bin/sh -c .../xcodebuild/dart.build/ReleaseIA32/upload_sdk.build/...
 
 
 ** BUILD SUCCEEDED **
 
   """
 
-  def is_empty_chunk(chunk):
+  def is_empty_chunk(input):
     empty_chunk = ['', 'Check dependencies', '']
-    return not chunk or (len(chunk) == 4 and chunk[1:] == empty_chunk)
+    return not input or (len(input) == 4 and input[1:] == empty_chunk)
 
   def unbuffered(callable):
     # Use iter to disable buffering in for-in.
     return iter(callable, '')
 
   section = None
   chunk = []
   # Is stdout a terminal which supports colors?
   is_fancy_tty = False
   clr_eol = None
@@ skipping 57 matching lines @@
 
 
 def NotifyBuildDone(build_config, success, start):
   if not success:
     print "BUILD FAILED"
 
   sys.stdout.flush()
 
   # Display a notification if build time exceeded DART_BUILD_NOTIFICATION_DELAY.
   notification_delay = float(
-    os.getenv('DART_BUILD_NOTIFICATION_DELAY', default=sys.float_info.max))
+    os.getenv('DART_BUILD_NOTIFICATION_DELAY', sys.float_info.max))
   if (time.time() - start) < notification_delay:
     return
 
   if success:
     message = 'Build succeeded.'
   else:
     message = 'Build failed.'
   title = build_config
 
   command = None
@@ skipping 103 matching lines @@
             if HOST_OS == 'freebsd':
               make = 'gmake'
               # work around lack of flock
               os.environ['LINK'] = '$(CXX)'
             args = [make,
                     '-j',
                     options.j,
                     'BUILDTYPE=' + build_config,
                     ]
             if target_os != HOST_OS:
-              args += ['builddir_name=' + utils.GetBuildDir(HOST_OS, target_os)]
+              args += ['builddir_name=' + utils.GetBuildDir(HOST_OS)]
             if options.verbose:
               args += ['V=1']
 
             args += [target]
 
           toolchainprefix = options.toolchain
           toolsOverride = SetTools(arch, target_os, toolchainprefix)
           if toolsOverride:
             for k, v in toolsOverride.iteritems():
               args.append(  k + "=" + v)
               if options.verbose:
                 print k + " = " + v
             if not os.path.isfile(toolsOverride['CC.target']):
               if arch == 'arm':
                 print arm_cc_error
               else:
                 print "Couldn't find compiler: %s" % toolsOverride['CC.target']
               return 1
 
 
           print ' '.join(args)
-          process = None
           if filter_xcodebuild_output:
             process = subprocess.Popen(args,
                                        stdin=None,
                                        bufsize=1, # Line buffered.
                                        stdout=subprocess.PIPE,
                                        stderr=subprocess.STDOUT)
             FilterEmptyXcodebuildSections(process)
           else:
             process = subprocess.Popen(args, stdin=None)
           process.wait()
           if process.returncode != 0:
             NotifyBuildDone(build_config, success=False, start=start_time)
             return 1
           else:
             NotifyBuildDone(build_config, success=True, start=start_time)
 
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(Main())