Python build script to make iOS JavaScriptCore.framework and wtf

TODO: Use libtool to link wtf into JavaScriptCore

Author: martijnthe

make.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python
+
+import argparse
+import logging
+import os
+import tempfile
+import shutil
+import subprocess
+from xcodebuild import FrameworkBuild
+
+"""Script to build JavaScriptCore.framework."""
+
+__author__ = "Martijn The"
+__email__ = "martijn@getpebble.com"
+
+
+class PebbleKitiOSException (Exception):
+    pass
+
+
+def build(out, derived_data_path):
+    outdir = out if out else tempfile.mkdtemp()
+
+    wtf = FrameworkBuild("WTF/WTF.xcodeproj",
+                         "WTF iOS", "Production", outdir, name="wtf",
+                         derived_data_path=derived_data_path)
+    wtf.build()
+
+    jsc = FrameworkBuild("JavaScriptCore/JavaScriptCore.xcodeproj",
+                         "JavaScriptCore iOS", "Production", outdir,
+                         name="JavaScriptCore",
+                         derived_data_path=derived_data_path)
+    jsc.build()
+
+    return outdir
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Build'
+                                     ' JavaScriptCore.framework')
+    parser.add_argument('--out', default=None, type=str,
+                        help="Output directory. Defaults to a random' \
+                        ' temporary folder.")
+    parser.add_argument('--derived-data', default=None, type=str,
+                        help="Derived data directory. Defaults to a random' \
+                        ' temporary folder.")
+    parser.add_argument('--verbose', action='store_const', default=False,
+                        const=True, help="Enable verbose logging.")
+    parser.add_argument('--no-open', action='store_const', default=True,
+                        const=False, help="Use `--no-open` to skip' \
+                        ' revealing the built product in Finder.")
+    args = parser.parse_args()
+
+    log_level = logging.INFO
+    if args.verbose:
+        log_level = logging.DEBUG
+    logging.basicConfig(format='[%(levelname)-8s] %(message)s',
+                        level=log_level)
+
+    outdir = build(args.out, args.derived_data)
+
+    if args.no_open:
+        os.system("open %s" % outdir)

xcodebuild.py

@@ -0,0 +1,193 @@
+#!/usr/bin/env python
+
+import logging
+import os
+import re
+import shutil
+import subprocess
+import tempfile
+
+"""Python wrapper around the xcodebuild command line program."""
+
+__author__ = "Martijn The"
+__email__ = "martijn@getpebble.com"
+
+DEFAULT_SDK_VERSION = "7.0"
+
+
+class PebbleXcodeBuildException (Exception):
+    pass
+
+
+class XcodeBuild(object):
+    sdk_version = "7.0"
+    conf = None
+    archs = None
+    project = None
+    scheme = None
+    derived_data_path = None
+    is_built = False
+
+    def __init__(self, project, derived_data_path=None):
+        self.project = project
+        self.derived_data_path = derived_data_path or tempfile.mkdtemp()
+        self.build_settings = {}
+
+    def _pre_build_sanity_check(self):
+        if self.scheme is None:
+            raise PebbleXcodeBuildException("No scheme set!")
+        if self.is_built:
+            raise PebbleXcodeBuildException("Already built!")
+
+    def _get_sdk_string(self):
+        is_device = len([arch for arch in self.archs
+                         if arch.startswith("arm")]) > 0
+        is_simulator = len([arch for arch in self.archs
+                            if arch.startswith("i386") or
+                            arch.startswith("x64")]) > 0
+        if is_device and is_simulator:
+            raise PebbleXcodeBuildException("Can't build for Device and"
+                                            "Simulator in one go! (archs=%s)" %
+                                            self.archs)
+        platform = ("iphoneos" if is_device else "iphonesimulator")
+        return platform + self.sdk_version
+
+    def _get_params(self):
+        params = []
+        if self.project:
+            params.extend(("-project", self.project))
+        if self.scheme:
+            params.extend(("-scheme", self.scheme))
+            params.extend(("-derivedDataPath", self.derived_data_path))
+        if self.conf:
+            params.extend(("-configuration", self.conf))
+        if self.archs:
+            concat_archs = " ".join(self.archs)
+            params.append("ARCHS=%s" % concat_archs)
+            # Auto-select SDK if archs is set:
+            sdk = self._get_sdk_string()
+            params.extend(("-sdk", sdk))
+        return params
+
+    def _xcodebuild(self, *actions):
+        self._pre_build_sanity_check()
+        params = self._get_params()
+        base_cmd = ["xcodebuild"] + params
+        actions_cmd = base_cmd + list(actions)
+        logging.debug("Executing: %s" % " ".join(actions_cmd))
+        if subprocess.call(actions_cmd):
+            raise PebbleXcodeBuildException("Build failed. xcodebuild exited"
+                                            "with non-zero return code (%s)" %
+                                            self.project)
+        # Collect the build settings that were used:
+        process = subprocess.Popen(base_cmd + ["-showBuildSettings"],
+                                   stdout=subprocess.PIPE)
+        if process.returncode:
+            raise PebbleXcodeBuildException("Gettings settings failed."
+                                            " xcodebuild exited with non-zero"
+                                            " return code (%s)" % self.project)
+        out = process.stdout.read()
+        settings_list = re.findall('\s*([A-Z_]+)\s*=\s*(.*)',
+                                   out, re.MULTILINE)
+        self.build_settings = {pair[0]: pair[1] for pair in settings_list}
+
+        self.is_built = True
+
+    def build(self):
+        self._xcodebuild("build")
+
+    def _check_is_built(self):
+        if not self.is_built:
+            raise PebbleXcodeBuildException("Cannot be accessed before build()"
+                                            "has been finished.")
+
+    def _path_from_build_settings_components(self, *setting_names):
+        self._check_is_built()
+        components = [self.build_settings[n] for n in setting_names]
+        # We want to treat absolute components as relative paths
+        concat_path = os.sep.join(components)
+        return os.path.normpath(concat_path)
+
+    def built_product_path(self):
+        return self._path_from_build_settings_components("BUILT_PRODUCTS_DIR",
+                                                         "FULL_PRODUCT_NAME")
+
+    def public_headers_path(self):
+        args = ("BUILT_PRODUCTS_DIR", "PUBLIC_HEADERS_FOLDER_PATH")
+        return self._path_from_build_settings_components(*args)
+
+
+class FrameworkBuild(object):
+    def __init__(self, project, scheme=None, conf="Release", outdir=None,
+                 name=None, derived_data_path=None):
+        self.scheme = scheme
+        self.name = name
+        self.devicebuild = XcodeBuild(project,
+                                      derived_data_path=derived_data_path)
+        self.simulatorbuild = XcodeBuild(project,
+                                         derived_data_path=derived_data_path)
+        self.outdir = outdir
+        for (bld, archs) in [self.devicebuild, ["arm64", "armv7", "armv7s"]], \
+                            [self.simulatorbuild, ["i386"]]:
+            bld.archs = archs
+            bld.scheme = scheme
+            bld.conf = conf
+
+    def build(self):
+        name = self.name or self.scheme
+        if " " in name:
+            name = name.replace(" ", "-")
+
+        # Run the builds of the libraries:
+        self.devicebuild.build()
+        self.simulatorbuild.build()
+
+        # Create the framework directory structure:
+        temp_dir = tempfile.mkdtemp()
+        framework_name = name + ".framework"
+        framework_dir = os.path.join(temp_dir, framework_name)
+        versions_dir = os.path.join(framework_dir, "Versions")
+        a_dir = os.path.join(versions_dir, "A")
+        lib_path = os.path.join(a_dir, name)
+        headers_dir = os.path.join(a_dir, "Headers")
+        os.makedirs(headers_dir)
+        os.symlink("A", os.path.join(versions_dir, "Current"))
+        os.symlink(os.path.join("Versions", "Current", "Headers"),
+                   os.path.join(framework_dir, "Headers"))
+        os.symlink(os.path.join("Versions", "Current", name),
+                   os.path.join(framework_dir, name))
+
+        # Move public headers:
+        os.renames(self.devicebuild.public_headers_path(), headers_dir)
+
+        # Use lipo to create one fat static library:
+        lipo_cmd = ["lipo", "-create",
+                    self.devicebuild.built_product_path(),
+                    self.simulatorbuild.built_product_path(),
+                    "-output", lib_path]
+        logging.debug("Executing: %s" % " ".join(lipo_cmd))
+        if subprocess.call(lipo_cmd):
+            raise PebbleXcodeBuildException("lipo failed")
+
+        # Move to outdir:
+        if self.outdir:
+            if not os.path.exists(self.outdir):
+                os.makedirs(self.outdir)
+            self._built_product_path = os.path.join(self.outdir,
+                                                    framework_name)
+            self._public_headers_path = os.path.join(self.outdir,
+                                                     framework_name,
+                                                     "Versions",
+                                                     "A", "Headers")
+            if os.path.exists(self._built_product_path):
+                shutil.rmtree(self._built_product_path)
+            os.rename(framework_dir, self._built_product_path)
+        else:
+            self._built_product_path = framework_dir
+            self._public_headers_path = headers_dir
+
+    def built_product_path(self):
+        return self._built_product_path
+
+    def public_headers_path(self):
+        return self._public_headers_path