*** This commit represents a complete reformatting of the LLDB source code

*** to conform to clang-format’s LLVM style.  This kind of mass change has
*** two obvious implications:

Firstly, merging this particular commit into a downstream fork may be a huge
effort.  Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit.  The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):

    find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
    find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;

The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.

Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit.  There are alternatives available that will attempt
to look through this change and find the appropriate prior commit.  YMMV.

llvm-svn: 280751

1 files changed, 168 insertions, 103 deletions

diff --git a/lldb/scripts/Xcode/build-llvm.py b/lldb/scripts/Xcode/build-llvm.py
index e7b91bc..ff474c27 100755
--- a/lldb/scripts/Xcode/build-llvm.py
+++ b/lldb/scripts/Xcode/build-llvm.py
@@ -13,64 +13,72 @@ from lldbbuild import *
 
 #### SETTINGS ####
 
-def LLVM_HASH_INCLUDES_DIFFS ():
+
+def LLVM_HASH_INCLUDES_DIFFS():
     return False
 
 # The use of "x = "..."; return x" here is important because tooling looks for
 # it with regexps.  Only change how this works if you know what you are doing.
 
-def LLVM_REF ():
+
+def LLVM_REF():
     llvm_ref = "master"
     return llvm_ref
 
-def CLANG_REF ():
+
+def CLANG_REF():
     clang_ref = "master"
     return clang_ref
 
 # For use with Xcode-style builds
 
-def XCODE_REPOSITORIES ():
+
+def XCODE_REPOSITORIES():
     return [
-        { 'name':   "llvm",
-          'vcs':    VCS.git,
-          'root':   llvm_source_path(),
-          'url':    "http://llvm.org/git/llvm.git",
-          'ref':    LLVM_REF() },
-
-        { 'name':   "clang",
-          'vcs':    VCS.git,
-          'root':   clang_source_path(),
-          'url':    "http://llvm.org/git/clang.git",
-          'ref':    CLANG_REF() },
-
-        { 'name':   "ninja",
-          'vcs':    VCS.git,
-          'root':   ninja_source_path(),
-          'url':    "https://github.com/ninja-build/ninja.git",
-          'ref':    "master" }
+        {'name': "llvm",
+         'vcs': VCS.git,
+         'root': llvm_source_path(),
+         'url': "http://llvm.org/git/llvm.git",
+         'ref': LLVM_REF()},
+
+        {'name': "clang",
+         'vcs': VCS.git,
+         'root': clang_source_path(),
+         'url': "http://llvm.org/git/clang.git",
+         'ref': CLANG_REF()},
+
+        {'name': "ninja",
+         'vcs': VCS.git,
+         'root': ninja_source_path(),
+         'url': "https://github.com/ninja-build/ninja.git",
+         'ref': "master"}
     ]
 
-def get_c_compiler ():
+
+def get_c_compiler():
     return subprocess.check_output([
         'xcrun',
         '--sdk', 'macosx',
         '-find', 'clang'
-        ]).rstrip()
+    ]).rstrip()
+
 
-def get_cxx_compiler ():
+def get_cxx_compiler():
     return subprocess.check_output([
         'xcrun',
         '--sdk', 'macosx',
         '-find', 'clang++'
-        ]).rstrip()
+    ]).rstrip()
 
 #                 CFLAGS="-isysroot $(xcrun --sdk macosx --show-sdk-path) -mmacosx-version-min=${DARWIN_DEPLOYMENT_VERSION_OSX}" \
 #                        LDFLAGS="-mmacosx-version-min=${DARWIN_DEPLOYMENT_VERSION_OSX}" \
 
-def get_deployment_target ():
+
+def get_deployment_target():
     return os.environ.get('MACOSX_DEPLOYMENT_TARGET', None)
 
-def get_c_flags ():
+
+def get_c_flags():
     cflags = ''
     # sdk_path = subprocess.check_output([
     #     'xcrun',
@@ -78,19 +86,21 @@ def get_c_flags ():
     #     '--show-sdk-path']).rstrip()
     # cflags += '-isysroot {}'.format(sdk_path)
 
-    deployment_target = get_deployment_target() 
+    deployment_target = get_deployment_target()
     if deployment_target:
         # cflags += ' -mmacosx-version-min={}'.format(deployment_target)
         pass
 
     return cflags
 
-def get_cxx_flags ():
+
+def get_cxx_flags():
     return get_c_flags()
 
-def get_common_linker_flags ():
+
+def get_common_linker_flags():
     linker_flags = ""
-    deployment_target = get_deployment_target() 
+    deployment_target = get_deployment_target()
     if deployment_target:
         # if len(linker_flags) > 0:
         #     linker_flags += ' '
@@ -99,50 +109,62 @@ def get_common_linker_flags ():
 
     return linker_flags
 
-def get_exe_linker_flags ():
+
+def get_exe_linker_flags():
     return get_common_linker_flags()
 
-def get_shared_linker_flags ():
+
+def get_shared_linker_flags():
     return get_common_linker_flags()
 
-def CMAKE_FLAGS ():
+
+def CMAKE_FLAGS():
     return {
         "Debug": [
             "-DCMAKE_BUILD_TYPE=RelWithDebInfo",
             "-DLLVM_ENABLE_ASSERTIONS=ON",
-            ],
+        ],
         "DebugClang": [
             "-DCMAKE_BUILD_TYPE=Debug",
             "-DLLVM_ENABLE_ASSERTIONS=ON",
-            ],
+        ],
         "Release": [
             "-DCMAKE_BUILD_TYPE=Release",
             "-DLLVM_ENABLE_ASSERTIONS=ON",
-            ],
+        ],
         "BuildAndIntegration": [
             "-DCMAKE_BUILD_TYPE=Release",
             "-DLLVM_ENABLE_ASSERTIONS=OFF",
-            ],
+        ],
     }
 
-def CMAKE_ENVIRONMENT ():
+
+def CMAKE_ENVIRONMENT():
     return {
     }
 
 #### COLLECTING ALL ARCHIVES ####
 
-def collect_archives_in_path (path): 
+
+def collect_archives_in_path(path):
     files = os.listdir(path)
     # Only use libclang and libLLVM archives, and exclude libclang_rt
     regexp = "^lib(clang[^_]|LLVM|gtest).*$"
-    return [os.path.join(path, file) for file in files if file.endswith(".a") and re.match(regexp, file)]
+    return [
+        os.path.join(
+            path,
+            file) for file in files if file.endswith(".a") and re.match(
+            regexp,
+            file)]
 
-def archive_list ():
+
+def archive_list():
     paths = library_paths()
     archive_lists = [collect_archives_in_path(path) for path in paths]
     return [archive for archive_list in archive_lists for archive in archive_list]
 
-def write_archives_txt ():
+
+def write_archives_txt():
     f = open(archives_txt(), 'w')
     for archive in archive_list():
         f.write(archive + "\n")
@@ -150,70 +172,92 @@ def write_archives_txt ():
 
 #### COLLECTING REPOSITORY MD5S ####
 
-def source_control_status (spec):
+
+def source_control_status(spec):
     vcs_for_spec = vcs(spec)
     if LLVM_HASH_INCLUDES_DIFFS():
         return vcs_for_spec.status() + vcs_for_spec.diff()
     else:
         return vcs_for_spec.status()
 
-def source_control_status_for_specs (specs):
+
+def source_control_status_for_specs(specs):
     statuses = [source_control_status(spec) for spec in specs]
     return "".join(statuses)
 
-def all_source_control_status ():
+
+def all_source_control_status():
     return source_control_status_for_specs(XCODE_REPOSITORIES())
 
-def md5 (string):
+
+def md5(string):
     m = hashlib.md5()
     m.update(string)
     return m.hexdigest()
 
-def all_source_control_status_md5 ():
+
+def all_source_control_status_md5():
     return md5(all_source_control_status())
 
 #### CHECKING OUT AND BUILDING LLVM ####
 
+
 def apply_patches(spec):
     files = os.listdir(os.path.join(lldb_source_path(), 'scripts'))
-    patches = [f for f in files if fnmatch.fnmatch(f, spec['name'] + '.*.diff')]
+    patches = [
+        f for f in files if fnmatch.fnmatch(
+            f, spec['name'] + '.*.diff')]
     for p in patches:
-        run_in_directory(["patch", "-p0", "-i", os.path.join(lldb_source_path(), 'scripts', p)], spec['root'])
+        run_in_directory(["patch",
+                          "-p0",
+                          "-i",
+                          os.path.join(lldb_source_path(),
+                                       'scripts',
+                                       p)],
+                         spec['root'])
+
 
 def check_out_if_needed(spec):
     if not os.path.isdir(spec['root']):
         vcs(spec).check_out()
         apply_patches(spec)
 
-def all_check_out_if_needed ():
-    map (check_out_if_needed, XCODE_REPOSITORIES())
 
-def should_build_llvm ():
+def all_check_out_if_needed():
+    map(check_out_if_needed, XCODE_REPOSITORIES())
+
+
+def should_build_llvm():
     if build_type() == BuildType.Xcode:
         # TODO use md5 sums
         return True
 
-def do_symlink (source_path, link_path):
+
+def do_symlink(source_path, link_path):
     print "Symlinking " + source_path + " to " + link_path
     if not os.path.exists(link_path):
         os.symlink(source_path, link_path)
 
-def setup_source_symlink (repo):
+
+def setup_source_symlink(repo):
     source_path = repo["root"]
     link_path = os.path.join(lldb_source_path(), os.path.basename(source_path))
     do_symlink(source_path, link_path)
 
-def setup_source_symlinks ():
+
+def setup_source_symlinks():
     map(setup_source_symlink, XCODE_REPOSITORIES())
 
-def setup_build_symlink ():
+
+def setup_build_symlink():
     # We don't use the build symlinks in llvm.org Xcode-based builds.
     if build_type() != BuildType.Xcode:
         source_path = package_build_path()
         link_path = expected_package_build_path()
         do_symlink(source_path, link_path)
 
-def should_run_cmake (cmake_build_dir):
+
+def should_run_cmake(cmake_build_dir):
     # We need to run cmake if our llvm build directory doesn't yet exist.
     if not os.path.exists(cmake_build_dir):
         return True
@@ -224,14 +268,17 @@ def should_run_cmake (cmake_build_dir):
     ninja_path = os.path.join(cmake_build_dir, "build.ninja")
     return not os.path.exists(ninja_path)
 
-def cmake_environment ():
+
+def cmake_environment():
     cmake_env = join_dicts(os.environ, CMAKE_ENVIRONMENT())
     return cmake_env
 
+
 def is_executable(path):
     return os.path.isfile(path) and os.access(path, os.X_OK)
 
-def find_executable_in_paths (program, paths_to_check):
+
+def find_executable_in_paths(program, paths_to_check):
     program_dir, program_name = os.path.split(program)
     if program_dir:
         if is_executable(program):
@@ -244,14 +291,16 @@ def find_executable_in_paths (program, paths_to_check):
                 return executable_file
     return None
 
-def find_cmake ():
+
+def find_cmake():
     # First check the system PATH env var for cmake
-    cmake_binary = find_executable_in_paths("cmake", os.environ["PATH"].split(os.pathsep))
+    cmake_binary = find_executable_in_paths(
+        "cmake", os.environ["PATH"].split(os.pathsep))
     if cmake_binary:
         # We found it there, use it.
         return cmake_binary
 
-    # Check a few more common spots.  Xcode launched from Finder 
+    # Check a few more common spots.  Xcode launched from Finder
     # will have the default environment, and may not have
     # all the normal places present.
     extra_cmake_dirs = [
@@ -263,18 +312,18 @@ def find_cmake ():
     if platform.system() == "Darwin":
         # Add locations where an official CMake.app package may be installed.
         extra_cmake_dirs.extend([
-           os.path.join(
-               os.path.expanduser("~"),
-               "Applications",
-               "CMake.app",
-               "Contents",
-               "bin"),
-           os.path.join(
-               os.sep,
-               "Applications",
-               "CMake.app",
-               "Contents",
-               "bin")])
+            os.path.join(
+                os.path.expanduser("~"),
+                "Applications",
+                "CMake.app",
+                "Contents",
+                "bin"),
+            os.path.join(
+                os.sep,
+                "Applications",
+                "CMake.app",
+                "Contents",
+                "bin")])
 
     cmake_binary = find_executable_in_paths("cmake", extra_cmake_dirs)
     if cmake_binary:
@@ -285,38 +334,42 @@ def find_cmake ():
     raise Exception(
         "could not find cmake in PATH ({}) or in any of these locations ({}), "
         "please install cmake or add a link to it in one of those locations".format(
-            os.environ["PATH"],
-            extra_cmake_dirs))
+            os.environ["PATH"], extra_cmake_dirs))
 
-def cmake_flags ():
+
+def cmake_flags():
     cmake_flags = CMAKE_FLAGS()[lldb_configuration()]
-    cmake_flags += [
-            "-GNinja",
-            "-DCMAKE_C_COMPILER={}".format(get_c_compiler()),
-            "-DCMAKE_CXX_COMPILER={}".format(get_cxx_compiler()),
-            "-DCMAKE_INSTALL_PREFIX={}".format(expected_package_build_path_for("llvm")),
-            "-DCMAKE_C_FLAGS={}".format(get_c_flags()),
-            "-DCMAKE_CXX_FLAGS={}".format(get_cxx_flags()),
-            "-DCMAKE_EXE_LINKER_FLAGS={}".format(get_exe_linker_flags()),
-            "-DCMAKE_SHARED_LINKER_FLAGS={}".format(get_shared_linker_flags())
-            ]
+    cmake_flags += ["-GNinja",
+                    "-DCMAKE_C_COMPILER={}".format(get_c_compiler()),
+                    "-DCMAKE_CXX_COMPILER={}".format(get_cxx_compiler()),
+                    "-DCMAKE_INSTALL_PREFIX={}".format(expected_package_build_path_for("llvm")),
+                    "-DCMAKE_C_FLAGS={}".format(get_c_flags()),
+                    "-DCMAKE_CXX_FLAGS={}".format(get_cxx_flags()),
+                    "-DCMAKE_EXE_LINKER_FLAGS={}".format(get_exe_linker_flags()),
+                    "-DCMAKE_SHARED_LINKER_FLAGS={}".format(get_shared_linker_flags())]
     deployment_target = get_deployment_target()
     if deployment_target:
-        cmake_flags.append("-DCMAKE_OSX_DEPLOYMENT_TARGET={}".format(deployment_target))
+        cmake_flags.append(
+            "-DCMAKE_OSX_DEPLOYMENT_TARGET={}".format(deployment_target))
     return cmake_flags
 
-def run_cmake (cmake_build_dir, ninja_binary_path):
+
+def run_cmake(cmake_build_dir, ninja_binary_path):
     cmake_binary = find_cmake()
     print "found cmake binary: using \"{}\"".format(cmake_binary)
 
     command_line = [cmake_binary] + cmake_flags() + [
-            "-DCMAKE_MAKE_PROGRAM={}".format(ninja_binary_path),
-            llvm_source_path()]
+        "-DCMAKE_MAKE_PROGRAM={}".format(ninja_binary_path),
+        llvm_source_path()]
     print "running cmake like so: ({}) in dir ({})".format(command_line, cmake_build_dir)
 
-    subprocess.check_call(command_line, cwd=cmake_build_dir, env=cmake_environment())
+    subprocess.check_call(
+        command_line,
+        cwd=cmake_build_dir,
+        env=cmake_environment())
+
 
-def create_directories_as_needed (path):
+def create_directories_as_needed(path):
     try:
         os.makedirs(path)
     except OSError as error:
@@ -325,16 +378,19 @@ def create_directories_as_needed (path):
         if error.errno != errno.EEXIST:
             raise error
 
-def run_cmake_if_needed (ninja_binary_path):
+
+def run_cmake_if_needed(ninja_binary_path):
     cmake_build_dir = package_build_path()
     if should_run_cmake(cmake_build_dir):
         # Create the build directory as needed
-        create_directories_as_needed (cmake_build_dir)
+        create_directories_as_needed(cmake_build_dir)
         run_cmake(cmake_build_dir, ninja_binary_path)
 
-def build_ninja_if_needed ():
+
+def build_ninja_if_needed():
     # First check if ninja is in our path.  If so, there's nothing to do.
-    ninja_binary_path = find_executable_in_paths("ninja", os.environ["PATH"].split(os.pathsep))
+    ninja_binary_path = find_executable_in_paths(
+        "ninja", os.environ["PATH"].split(os.pathsep))
     if ninja_binary_path:
         # It's on the path.  cmake will find it.  We're good.
         print "found ninja here: \"{}\"".format(ninja_binary_path)
@@ -347,20 +403,29 @@ def build_ninja_if_needed ():
         # Build ninja
         command_line = ["python", "configure.py", "--bootstrap"]
         print "building ninja like so: ({}) in dir ({})".format(command_line, ninja_build_dir)
-        subprocess.check_call(command_line, cwd=ninja_build_dir, env=os.environ)
+        subprocess.check_call(
+            command_line,
+            cwd=ninja_build_dir,
+            env=os.environ)
 
     return ninja_binary_path
 
-def join_dicts (dict1, dict2):
+
+def join_dicts(dict1, dict2):
     d = dict1.copy()
     d.update(dict2)
     return d
 
-def build_llvm (ninja_binary_path):
+
+def build_llvm(ninja_binary_path):
     cmake_build_dir = package_build_path()
-    subprocess.check_call([ninja_binary_path], cwd=cmake_build_dir, env=cmake_environment())
+    subprocess.check_call(
+        [ninja_binary_path],
+        cwd=cmake_build_dir,
+        env=cmake_environment())
+
 
-def build_llvm_if_needed ():
+def build_llvm_if_needed():
     if should_build_llvm():
         ninja_binary_path = build_ninja_if_needed()
         run_cmake_if_needed(ninja_binary_path)