| #!/usr/bin/env python |
| # -*- coding: utf-8 -*- |
| # |
| # Copyright (C) 2019 Apple Inc. All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions |
| # are met: |
| # |
| # 1. Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # 2. Redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution. |
| # |
| # THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY |
| # EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR |
| # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY |
| # OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| # BaseGenerator is the base class for generating new .xcfilelist content. Most |
| # of the implementation is provided in this base class. Subclasses are created |
| # to provide project-specific information, such as the path to the project file |
| # and valid platform and configuration information. |
| # |
| # Instances of this class are create for each project/platform/configuration |
| # triple. For each triple, .xcfilelist content is generated and compared to the |
| # file that ultimately will contain that information. Any new lines are |
| # determined and remembered for later addition to that destination file. |
| # |
| # Instances of this class can operate in either of two contexts. First, it's |
| # possible for Xcode projects to invoke this script in order to keep their |
| # .xcfilelist files up-to-date. In that case, this script starts out running in |
| # the context of Xcode and it can just go ahead and generate the new content. |
| # Alternatively, it's possible for someone to invoke this script from the |
| # command line. In that case, this script needs to sublaunch itself in order to |
| # expose itself to the environment variables that Xcode establishes during |
| # builds. This script thus starts out as a free-standing script, creates a |
| # BaseGenerator for the .xcfilelist content it needs to create, sub-launches |
| # itself, and then creates another BaseGenerator to do the actual generation. |
| # When this inner instance of the script exits, it writes the results of the |
| # BaseGenerators to a temporary file. When the outer instance of the script |
| # resumes, it reads the information from that temporary file. That information |
| # is actually just a serialized (pickled) BaseGenerator instance and is |
| # restored as such. This restored BaseGenerator now replaces the original |
| # BaseGenerator in the outer script that caused it to be created, since the |
| # inner one is the one with all the xcfilelist information. |
| |
| from __future__ import print_function |
| |
| import os |
| import pickle |
| import tempfile |
| import traceback |
| |
| import webkitpy.generate_xcfilelists_lib.util as util |
| from webkitpy.xcode import xcode_hash_for_path |
| from webkitpy.xcode.sdk import SDK |
| from webkitpy.common.attribute_saver import AttributeSaver |
| |
| |
| class BaseGenerator(object): |
| __slots__ = ( |
| "application", "project_tag", "platform", "configuration", "triple", |
| "ex_type", "ex_value", "ex_traceback", |
| "added_lines_input_derived", "added_lines_output_derived", "added_lines_input_unified", "added_lines_output_unified", |
| "cached_build_dirs") |
| |
| VALID_PLATFORMS = None |
| VALID_CONFIGURATIONS = None |
| |
| @util.LogEntryExit |
| def __init__(self, application, project_tag, platform, configuration): |
| self.application = application |
| self.project_tag = project_tag |
| self.platform = platform |
| self.configuration = configuration |
| self.triple = (project_tag, platform, configuration) |
| |
| self.ex_type = None |
| self.ex_value = None |
| self.ex_traceback = None |
| |
| self.added_lines_input_derived = None |
| self.added_lines_output_derived = None |
| self.added_lines_input_unified = None |
| self.added_lines_output_unified = None |
| |
| self.cached_build_dirs = None |
| |
| def __str__(self): |
| return "project_tag = {}, platform = {}, configuration = {}, ex_type = {}, ex_value = {}, ex_traceback = {}, added_lines_input_derived = {}, added_lines_output_derived = {}, added_lines_input_unified = {}, added_lines_output_unified = {}, cached_build_dirs = {}".format( |
| self.project_tag, self.platform, self.configuration, |
| self.ex_type, self.ex_value, self.ex_traceback, |
| self.added_lines_input_derived, self.added_lines_output_derived, self.added_lines_input_unified, self.added_lines_output_unified, |
| self.cached_build_dirs) |
| |
| # Generate new .xcfilist list contents and return any new lines. This |
| # generation is performed by relaunching ourselves under Xcode so that we |
| # can operate in the context of its environment variables. When we relaunch |
| # ourselves, we do so in a way that invokes this class's generate() |
| # method. Any results from generate are written to a temporary file that |
| # we set up here. When the relaunched instance completes, we reads those |
| # results from the temporary file. |
| |
| @util.LogEntryExit |
| def set_environment_and_generate(self): |
| with tempfile.NamedTemporaryFile() as pickle_file, tempfile.NamedTemporaryFile() as debug_file: |
| sublaunch_args = [ |
| "PATH=\"{}:${{PATH}}\"".format(self._getenv("PATH")), # Xcode will "sanitize" PATH, such that Python is no longer on it, so get /usr/bin back in PATH. |
| "PYTHONPATH=\"{}\"".format(self._getenv("PYTHONPATH", "")), |
| self.application.get_generate_xcfilelists_script_path(), |
| "generate-inner", |
| "--project", self.project_tag, |
| "--platform", self.platform, |
| "--configuration", self.configuration, |
| "--pickle-file", pickle_file.name] |
| if self.application.cmd_line_args.debug: |
| sublaunch_args += [ |
| "--debug", |
| "--debug-file", debug_file.name] |
| if self.application.cmd_line_args.quiet: |
| sublaunch_args.append("--quiet") |
| |
| try: |
| self._sublaunch_under_xcode(sublaunch_args) |
| finally: |
| # If xcodebuild returns an error, we want to at least display the |
| # debugging information. |
| if self.application.cmd_line_args.debug: |
| for line in debug_file: |
| util.debug_log("{}".format(line.rstrip())) |
| |
| generators = [] |
| while True: |
| try: |
| generator = pickle.load(pickle_file) |
| generator.application = self.application |
| generators.append(generator) |
| except EOFError as e: |
| break |
| return generators |
| |
| # Relaunch this script under Xcode. This is performed by launching Xcode, |
| # pointing it to the project that we are processing as well as a build |
| # target that will re-execute us as a custom build step. |
| |
| @util.LogEntryExit |
| def _sublaunch_under_xcode(self, sublaunch_args): |
| xcode_parameters = [ |
| "xcodebuild", |
| "-project", self._get_project_file_path(), |
| "-sdk", SDK.get_preferred_sdk_for_platform(self.platform).as_xcode_specification(), |
| "-configuration", self.configuration, |
| "-target", "Apply Configuration to XCFileLists", |
| "SYMROOT={}".format(self._get_sym_root()), |
| "OBJROOT={}".format(self._get_obj_root()), |
| "SHARED_PRECOMPS_DIR={}".format(self._get_shared_precomps_dir())] |
| |
| # TODO: sublaunch_args will contain the path to the script to |
| # sublaunch. There might be a problem if there's a space in that path. |
| util.subprocess_run(xcode_parameters, |
| env={"WK_SUBLAUNCH_SCRIPT_PARAMETERS": " ".join(sublaunch_args)}) |
| |
| # Generate the .xcfilelist content. Save the results internally as sets of |
| # new lines to be added to the .xcfilelist files. These new lines can be |
| # merged into those files if the user specified a "generate" command, or |
| # can be reported in a "check" command. |
| |
| @util.LogEntryExit |
| def generate(self): |
| self._generate_derived() |
| self._generate_unified() |
| |
| # Merge any saved added lines to their ultimate destinations. |
| |
| @util.LogEntryExit |
| def merge(self): |
| self._merge_derived() |
| self._merge_unified() |
| |
| @util.LogEntryExit |
| def pickle_to_file(self, f): |
| # We don't want to pickle the application reference |
| # We can't seem to pickle ex_traceback: PicklingError: Can't pickle <type 'traceback'>: it's not found as __builtin__.traceback |
| with AttributeSaver(self, "application"), AttributeSaver(self, "ex_traceback"): |
| pickle.dump(self, f, pickle.HIGHEST_PROTOCOL) |
| |
| # Return whether or not any new lines for any .xcfilelist files were |
| # discovered. |
| |
| @util.LogEntryExit |
| def has_action(self): |
| return (self.added_lines_input_derived or |
| self.added_lines_output_derived or |
| self.added_lines_input_unified or |
| self.added_lines_output_unified) |
| |
| # If any errors occur during the generation of .xcfilelist content, they |
| # are remembered internally for later processing. This function returns |
| # whether or not any such error occurred with this generator. |
| |
| @util.LogEntryExit |
| def has_error(self): |
| return self.ex_type |
| |
| # Return whether or not the combination of project, platform, and |
| # configuration is valid (which is to say, if, for example, the given |
| # project can be built for the given platform and configuration). |
| |
| @util.LogEntryExit |
| def is_valid(self): |
| return (self.platform in self.__class__.VALID_PLATFORMS and |
| self.configuration in self.__class__.VALID_CONFIGURATIONS) |
| |
| # If an error/exception occurred and was recorded (that is, if has_error() |
| # returns true), report that error to the console. |
| |
| @util.LogEntryExit |
| def report_error(self): |
| try: |
| if self.ex_value: |
| raise self.ex_value |
| except KeyboardInterrupt: |
| print("### Canceled") |
| except util.CalledProcessError as e: |
| print("### Error {} calling subprocess: {}".format(e.args[0], e.args[1])) |
| if e.args[2]: |
| print("### stdout = {}".format(e.args[2])) |
| if e.args[3]: |
| print("### stderr = {}".format(e.args[3])) |
| except util.InvalidConfigurationError as e: |
| print("### Invalid configuration: {}".format(e)) |
| return os.EX_USAGE |
| except BaseException: |
| traceback.print_exception(self.ex_type, self.ex_value, self.ex_traceback) |
| return os.EX_SOFTWARE |
| |
| # Generate .xcfilelist content for the "Generate Derived Sources" build |
| # phase. |
| |
| @util.LogEntryExit |
| def _generate_derived(self): |
| script = self._get_generate_derived_sources_script() |
| if not script: |
| return |
| |
| with tempfile.NamedTemporaryFile() as input, tempfile.NamedTemporaryFile() as output: |
| (stdout, stderr) = util.subprocess_run( |
| [script, |
| "NO_SUPPLEMENTAL_FILES=1", |
| "--no-builtin-rules", |
| "--dry-run", |
| "--always-make", |
| "--debug=abvijm", |
| "all"]) |
| stdout = stdout.encode() if isinstance(stdout, str) else stdout |
| (stdout, stderr) = util.subprocess_run( |
| [self.application.get_extract_dependencies_from_makefile_script(), |
| "--input", input.name, |
| "--output", output.name], |
| input=stdout) |
| |
| # TODO: Make this generator-specific (there's no need to reference |
| # WebCore, for example, when processing the JavaScriptCore |
| # project). |
| |
| self._replace(input.name, "^JavaScriptCore/", "$(PROJECT_DIR)/") |
| self._replace(input.name, "^JavaScriptCorePrivateHeaders/", "$(JAVASCRIPTCORE_PRIVATE_HEADERS_DIR)/") |
| self._replace(input.name, "^WebCore/", "$(PROJECT_DIR)/") |
| self._replace(input.name, "^WebKit2PrivateHeaders/", "$(WEBKIT2_PRIVATE_HEADERS_DIR)/") |
| |
| self._unexpand(input.name, "JAVASCRIPTCORE_PRIVATE_HEADERS_DIR") |
| self._unexpand(input.name, "PROJECT_DIR") |
| self._unexpand(input.name, "WEBCORE_PRIVATE_HEADERS_DIR") |
| self._unexpand(input.name, "WEBKIT2_PRIVATE_HEADERS_DIR") |
| self._unexpand(input.name, "WEBKITADDITIONS_HEADERS_FOLDER_PATH") |
| self._unexpand(input.name, "BUILT_PRODUCTS_DIR") # Do this last, since it's a prefix of some other variables and will "intercept" them if executed earlier than them. |
| |
| self._replace(output.name, "^", self._get_derived_sources_dir() + "/") |
| self._unexpand(output.name, "BUILT_PRODUCTS_DIR") |
| |
| self.added_lines_input_derived = self._find_added_lines(input.name, self._get_input_derived_xcfilelist_project_path()) |
| self.added_lines_output_derived = self._find_added_lines(output.name, self._get_output_derived_xcfilelist_project_path()) |
| |
| @util.LogEntryExit |
| def _merge_derived(self): |
| self._merge_added_lines(self.added_lines_input_derived, self._get_input_derived_xcfilelist_project_path()) |
| self._merge_added_lines(self.added_lines_output_derived, self._get_output_derived_xcfilelist_project_path()) |
| |
| # Generate .xcfilelist content for the "Generate Unified Sources" build |
| # phase. |
| |
| @util.LogEntryExit |
| def _generate_unified(self): |
| script = self._get_generate_unified_sources_script() |
| if not script: |
| return |
| |
| with tempfile.NamedTemporaryFile() as output: |
| |
| # We need to define BUILD_SCRIPTS_DIR so that the bash script we're |
| # invoking can find the ruby script that it invokes. If we don't |
| # define BUILD_SCRIPTS_DIR, the bash script we're invoking with try |
| # to define its own value for BUILD_SCRIPTS_DIR, but it will do so |
| # incorrectly for our purposes, leading to dire results. |
| |
| env = os.environ.copy() |
| env["BUILD_SCRIPTS_DIR"] = self.application.get_build_scripts_dir() |
| |
| util.subprocess_run( |
| [script, |
| "--generate-xcfilelists", |
| "--output-xcfilelist-path", output.name], |
| env=env) |
| |
| self._unexpand(output.name, "BUILT_PRODUCTS_DIR") |
| |
| self.added_lines_input_unified = self._find_added_lines(None, self._get_input_unified_xcfilelist_project_path()) |
| self.added_lines_output_unified = self._find_added_lines(output.name, self._get_output_unified_xcfilelist_project_path()) |
| |
| @util.LogEntryExit |
| def _merge_unified(self): |
| self._merge_added_lines(self.added_lines_input_unified, self._get_input_unified_xcfilelist_project_path()) |
| self._merge_added_lines(self.added_lines_output_unified, self._get_output_unified_xcfilelist_project_path()) |
| |
| # Utility for post-processing the initial .xcfilelist content. Used to |
| # replace text in the file. |
| |
| @util.LogEntryExit |
| def _replace(self, file_name, to_replace, replace_with): |
| util.subprocess_run([ |
| "sed", "-E", "-e", |
| "s|{}|{}|".format(to_replace, replace_with), |
| "-i", "''", file_name]) |
| |
| # Utility for post-processing the initial .xcfilelist content. Used to |
| # replace file path segments with the variables that represent those path |
| # segments. |
| |
| @util.LogEntryExit |
| def _unexpand(self, file_name, variable_name): |
| to_replace = self._getenv(variable_name) |
| if not to_replace: |
| return |
| |
| self._replace(file_name, "^{}/".format(to_replace), "$({})/".format(variable_name)) |
| |
| # Given a source file with new .xcfilelist content and a dest file that |
| # contains the original/previous .xcfilelist content (that is, likely the |
| # file that's checked into the repo), determine what, if any, new lines |
| # there are in source that aren't in dest. |
| |
| @util.LogEntryExit |
| def _find_added_lines(self, source, dest): |
| if not source: |
| return set() |
| source_lines = set(source) if isinstance(source, list) else self._get_file_lines(source) |
| dest_lines = set(dest) if isinstance(dest, list) else self._get_file_lines(dest) |
| delta_lines = source_lines - dest_lines |
| return delta_lines |
| |
| # Bottleneck routine for taking a set of new lines of .xcfilelist content |
| # and adding them to their ultimate file/destination. |
| |
| @util.LogEntryExit |
| def _merge_added_lines(self, added_lines, dest): |
| if not added_lines: |
| return |
| dest_lines = self._get_file_lines(dest) |
| merged_lines = sorted(set(added_lines) | dest_lines) |
| merged_lines = [line + "\n" for line in merged_lines if line and not line.startswith("#")] |
| merged_lines[0:0] = ["# This file is generated by the generate-xcfilelists script.\n"] |
| with open(dest, "w") as f: |
| f.writelines(merged_lines) |
| |
| # Utility to read a file and results the contents as a set of lines with |
| # EOLs removed. |
| |
| @util.LogEntryExit |
| def _get_file_lines(self, file): |
| try: |
| with open(file, "r") as f: |
| return set([line.strip() for line in f]) |
| except: |
| return set() |
| |
| # Wrapper to return environment variable values. |
| |
| @util.LogEntryExit |
| def _getenv(self, variable_name, default=None): |
| return os.environ.get(variable_name, default) |
| |
| # Return the path to the project file (the *.xcodeproj "file). |
| |
| @util.LogEntryExit |
| def _get_project_file_path(self): |
| assert False, """\ |
| Override this to return full path to the project file (e.g., |
| ".../Source/JavaScriptCore/JavaScriptCode.xcodeproj").""" |
| |
| # Return the path to the directory containing the project file and its |
| # supporting files and directories (e.g., ".../Source/JavaScriptCore"). |
| |
| @util.LogEntryExit |
| def _get_project_dir(self): |
| return os.path.dirname(self._get_project_file_path()) |
| |
| # Return the project file name (e.g., "JavaScriptCore.xcodeproj"). |
| |
| @util.LogEntryExit |
| def _get_project_file_name(self): |
| return os.path.basename(self._get_project_file_path()) |
| |
| # Return the project name (e.g., "JavaScriptCore"). |
| |
| @util.LogEntryExit |
| def _get_project_name(self): |
| return os.path.splitext(self._get_project_file_name())[0] |
| |
| # Return the path to the build output directory to use when the user has |
| # indicated that they are building from the command line. Be sure to |
| # support default command-line users, command-line users that set |
| # WEBKIT_OUTPUTDIR, default Xcode users, and people like Jeff Miller who |
| # configure a custom build output location for Xcode. |
| |
| @util.LogEntryExit |
| def _get_sym_root(self): |
| return self._get_build_dirs()[0] |
| |
| @util.LogEntryExit |
| def _get_obj_root(self): |
| return self._get_build_dirs()[1] |
| |
| @util.LogEntryExit |
| def _get_shared_precomps_dir(self): |
| return os.path.join(self._get_build_dirs()[1], "PrecompiledHeaders") |
| |
| # From Xcode; |
| # |
| # export SYMROOT =/Users/keith/Library/Developer/Xcode/DerivedData/Safari-bmjhivzkbpxamlajyexvkivfjbmb/Build/Products |
| # export OBJROOT =/Users/keith/Library/Developer/Xcode/DerivedData/Safari-bmjhivzkbpxamlajyexvkivfjbmb/Build/Intermediates.noindex |
| # export SHARED_PRECOMPS_DIR=/Users/keith/Library/Developer/Xcode/DerivedData/Safari-bmjhivzkbpxamlajyexvkivfjbmb/Build/Intermediates.noindex/PrecompiledHeaders |
| # |
| # From command-line: |
| # |
| # export SYMROOT =/Volumes/Data/dev/webkit/OpenSource/WebKitBuild |
| # export OBJROOT =/Volumes/Data/dev/webkit/OpenSource/WebKitBuild |
| # export SHARED_PRECOMPS_DIR=/Volumes/Data/dev/webkit/OpenSource/WebKitBuild/PrecompiledHeaders |
| |
| @util.LogEntryExit |
| def _get_build_dirs(self): |
| def define_xcode_build_dirs(self): |
| # Delete any spurious ~/Library/Preferences/xcodebuild.plist, as this |
| # file will interfere with any preferences set in the IDE. This |
| # .plist file shouldn't really ever exist, so nuking it doesn't |
| # cause any problems. |
| |
| xcodebuild_plist = os.path.join(os.path.expanduser("~"), "Library", "Preferences", "xcodebuild.plist") |
| try: |
| os.unlink(xcodebuild_plist) |
| except: |
| pass |
| |
| def read_xcode_user_default(key): |
| try: |
| (stdout, stderr) = util.subprocess_run(["defaults", "read", "com.apple.dt.Xcode", key]) |
| return stdout.strip() |
| except util.CalledProcessError: |
| return None |
| |
| # The following is based on the logic in determineBaseProductDir() |
| # in webkitdirs.pm and https://pewpewthespells.com/blog/xcode_build_locations.html. |
| |
| # Get the base directory for the build output. This will be some |
| # default location (e.g., ~/Library/Developer/Xcode/DerivedData), |
| # an absolute path, or a project-relative path. |
| |
| ide_custom_derived_data_location = read_xcode_user_default("IDECustomDerivedDataLocation") |
| |
| # Path not specified; use the default. |
| |
| if not ide_custom_derived_data_location: |
| base_dir = os.path.join(os.path.expanduser("~"), "Library", "Developer", "Xcode", "DerivedData") |
| |
| # An absolute path is specified; use it. |
| |
| elif os.path.isabs(ide_custom_derived_data_location): |
| base_dir = ide_custom_derived_data_location |
| |
| # A relative path is specified; append it to the project path. |
| |
| else: |
| base_dir = os.path.join(self._get_project_dir(), ide_custom_derived_data_location) |
| |
| # Get the specification for how the build output should be stored |
| # withing that base directory. This will be some unique directory |
| # based on the hash of the project file path (e.g., |
| # "Safari-sdlfkhasalksdjfhsdfhlksf"), some shared directory (e.g., |
| # "Build"), or even something that might be an absolute path. |
| |
| ide_build_location_style = read_xcode_user_default("IDEBuildLocationStyle") |
| |
| # Create a unique directory within the base directory based on |
| # project name and hash of its full path. |
| # |
| # IDEBuildLocationStyle = Unique; # This is the default if not specified. |
| |
| if ide_build_location_style == "Unique" or not ide_build_location_style: |
| workspace = os.path.abspath(self.application.cmd_line_args.xcode) |
| build_dir = os.path.join( |
| base_dir, |
| os.path.splitext(os.path.basename(workspace))[0] + "-" + xcode_hash_for_path(workspace), |
| "Build") |
| products_dir = os.path.join(build_dir, "Products") |
| intermediates_dir = os.path.join(build_dir, "Intermediates.noindex") |
| |
| # Use a shared subdirectory; use the specified directory name. |
| # |
| # IDEBuildLocationStyle = Shared; |
| # IDESharedBuildFolderName = Build; # Relative to DerivedDataLocation |
| |
| elif ide_build_location_style == "Shared": |
| build_dir = os.path.join(base_dir, read_xcode_user_default("IDESharedBuildFolderName")) |
| products_dir = os.path.join(build_dir, "Products") |
| intermediates_dir = os.path.join(build_dir, "Intermediates.noindex") |
| |
| # Use the saved products and intermediates paths and either use |
| # them as relative to the DerivedData directory or the project |
| # folder, or just use them as absolute addresses. |
| # |
| # IDEBuildLocationStyle = Custom; |
| |
| elif ide_build_location_style == "Custom": |
| ide_build_location_type = read_xcode_user_default("IDECustomBuildLocationType") |
| |
| products_dir = read_xcode_user_default("IDECustomBuildProductsPath") |
| intermediates_dir = read_xcode_user_default("IDECustomBuildIntermediatesPath") |
| |
| # IDECustomBuildLocationType = RelativeToDerivedData; |
| # IDECustomBuildIntermediatesPath = "Build/Intermediates.noindex"; |
| # IDECustomBuildProductsPath = "Build/Products"; |
| # IDECustomIndexStorePath = "Index/DataStore"; |
| |
| if ide_build_location_type == "RelativeToDerivedData": |
| products_dir = os.path.join(base_dir, products_dir) |
| intermediates_dir = os.path.join(base_dir, intermediates_dir) |
| |
| # IDECustomBuildLocationType = RelativeToWorkspace; |
| # IDECustomBuildIntermediatesPath = "Build/Intermediates.noindex"; |
| # IDECustomBuildProductsPath = "Build/Products"; |
| # IDECustomIndexStorePath = "Index/DataStore"; |
| |
| elif ide_build_location_type == "RelativeToWorkspace": |
| base_dir = self._get_project_dir(), |
| products_dir = os.path.join(base_dir, products_dir) |
| intermediates_dir = os.path.join(base_dir, intermediates_dir) |
| |
| # IDECustomBuildLocationType = Absolute; |
| # IDECustomBuildIntermediatesPath = "/Users/joedeveloper/Desktop/Build/Intermediates.noindex"; |
| # IDECustomBuildProductsPath = "/Users/joedeveloper/Desktop/Build/Products"; |
| # IDECustomIndexStorePath = "/Users/joedeveloper/Desktop/Index/DataStore"; |
| # IDECustomDerivedDataLocation = "/Users/joedeveloper/Library/Developer/Xcode/DerivedData"; |
| |
| elif ide_build_location_type == "Absolute": |
| pass |
| |
| else: |
| assert False, "Unknown/unsupported location type" |
| else: |
| assert False, "Unknown/unsupported style" |
| |
| return (products_dir, intermediates_dir) |
| |
| def define_command_line_build_dirs(self): |
| products_dir = self._getenv("WEBKIT_OUTPUTDIR") |
| if not products_dir: |
| products_dir = os.path.join(self.application.get_opensource_dir(), "WebKitBuild") |
| return (products_dir, products_dir) |
| |
| if not self.cached_build_dirs and self.application.cmd_line_args.xcode: |
| self.cached_build_dirs = define_xcode_build_dirs(self) |
| if not self.cached_build_dirs: |
| self.cached_build_dirs = define_command_line_build_dirs(self) |
| return self.cached_build_dirs |
| |
| # Return the location of the DerivedSources directory. Conventionally, we |
| # use $BUILT_PRODUCTS/DerivedSources/$PROJECT_NAME, but we may some day use |
| # $DERIVED_FILE_DIR aka $DERIVED_FILES_DIR aka $DERIVED_SOURCES_DIR, when |
| # the projects have been updated to use them. |
| |
| @util.LogEntryExit |
| def _get_derived_sources_dir(self): |
| return os.path.join(self.application.get_xcode_built_products_dir(), "DerivedSources", self._get_project_name()) |
| |
| # Return the location for the xcfilelists. |
| |
| @util.LogEntryExit |
| def _get_xcfilelist_dir(self): |
| return self._get_project_dir() |
| |
| # Return the paths to the actual xcfilelists. |
| |
| @util.LogEntryExit |
| def _get_input_derived_xcfilelist_project_path(self): |
| return os.path.join(self._get_xcfilelist_dir(), "DerivedSources-input.xcfilelist") |
| |
| @util.LogEntryExit |
| def _get_output_derived_xcfilelist_project_path(self): |
| return os.path.join(self._get_xcfilelist_dir(), "DerivedSources-output.xcfilelist") |
| |
| @util.LogEntryExit |
| def _get_input_unified_xcfilelist_project_path(self): |
| return os.path.join(self._get_xcfilelist_dir(), "UnifiedSources-input.xcfilelist") |
| |
| @util.LogEntryExit |
| def _get_output_unified_xcfilelist_project_path(self): |
| return os.path.join(self._get_xcfilelist_dir(), "UnifiedSources-output.xcfilelist") |
| |
| # Return the paths to the scripts that generate the derived sources. |
| |
| @util.LogEntryExit |
| def _get_generate_derived_sources_script(self): |
| return None |
| |
| @util.LogEntryExit |
| def _get_generate_unified_sources_script(self): |
| return None |
| |
| |
| class JavaScriptCoreGenerator(BaseGenerator): |
| VALID_PLATFORMS = ("macosx", "iosmac", "iphoneos", "watchos") |
| VALID_CONFIGURATIONS = ("Debug", "Release", "Production", "Profiling") |
| |
| @util.LogEntryExit |
| def _get_project_file_path(self): |
| return os.path.join(self.application.get_opensource_dir(), "Source", "JavaScriptCore", "JavaScriptCore.xcodeproj") |
| |
| @util.LogEntryExit |
| def _get_generate_derived_sources_script(self): |
| return os.path.join(self._get_project_dir(), "Scripts", "generate-derived-sources.sh") |
| |
| @util.LogEntryExit |
| def _get_generate_unified_sources_script(self): |
| return os.path.join(self._get_project_dir(), "Scripts", "generate-unified-sources.sh") |
| |
| |
| class WebCoreGenerator(BaseGenerator): |
| VALID_PLATFORMS = ("macosx", "iosmac", "iphoneos", "watchos") |
| VALID_CONFIGURATIONS = ("Debug", "Release", "Production") |
| |
| @util.LogEntryExit |
| def _get_project_file_path(self): |
| return os.path.join(self.application.get_opensource_dir(), "Source", "WebCore", "WebCore.xcodeproj") |
| |
| @util.LogEntryExit |
| def _get_generate_derived_sources_script(self): |
| return os.path.join(self._get_project_dir(), "Scripts", "generate-derived-sources.sh") |
| |
| @util.LogEntryExit |
| def _get_generate_unified_sources_script(self): |
| return os.path.join(self._get_project_dir(), "Scripts", "generate-unified-sources.sh") |
| |
| |
| class WebKitGenerator(BaseGenerator): |
| VALID_PLATFORMS = ("macosx", "iosmac", "iphoneos", "watchos") |
| VALID_CONFIGURATIONS = ("Debug", "Release", "Production") |
| |
| @util.LogEntryExit |
| def _get_project_file_path(self): |
| return os.path.join(self.application.get_opensource_dir(), "Source", "WebKit", "WebKit.xcodeproj") |
| |
| @util.LogEntryExit |
| def _get_derived_sources_dir(self): |
| return os.path.join(self.application.get_xcode_built_products_dir(), "DerivedSources", "WebKit2") |
| |
| @util.LogEntryExit |
| def _get_generate_derived_sources_script(self): |
| return os.path.join(self._get_project_dir(), "Scripts", "generate-derived-sources.sh") |
| |
| @util.LogEntryExit |
| def _get_generate_unified_sources_script(self): |
| return os.path.join(self._get_project_dir(), "Scripts", "generate-unified-sources.sh") |
| |
| |
| class DumpRenderTreeGenerator(BaseGenerator): |
| VALID_PLATFORMS = ("macosx", ) |
| VALID_CONFIGURATIONS = ("Debug", "Release", "Production") |
| |
| @util.LogEntryExit |
| def _get_project_file_path(self): |
| return os.path.join(self.application.get_opensource_dir(), "Tools", "DumpRenderTree", "DumpRenderTree.xcodeproj") |
| |
| @util.LogEntryExit |
| def _get_generate_derived_sources_script(self): |
| return os.path.join(self._get_project_dir(), "Scripts", "generate-derived-sources.sh") |
| |
| |
| class WebKitTestRunnerGenerator(BaseGenerator): |
| VALID_PLATFORMS = ("macosx", ) |
| VALID_CONFIGURATIONS = ("Debug", "Release", "Production") |
| |
| @util.LogEntryExit |
| def _get_project_file_path(self): |
| return os.path.join(self.application.get_opensource_dir(), "Tools", "WebKitTestRunner", "WebKitTestRunner.xcodeproj") |
| |
| @util.LogEntryExit |
| def _get_generate_derived_sources_script(self): |
| return os.path.join(self._get_project_dir(), "Scripts", "generate-derived-sources.sh") |
