| #!/usr/bin/python2.7 | |
| # Copyright 2015 The Bazel Authors. All rights reserved. | |
| # | |
| # Licensed under the Apache License, Version 2.0 (the "License"); | |
| # you may not use this file except in compliance with the License. | |
| # You may obtain a copy of the License at | |
| # | |
| # http:#www.apache.org/licenses/LICENSE-2.0 | |
| # | |
| # Unless required by applicable law or agreed to in writing, software | |
| # distributed under the License is distributed on an "AS IS" BASIS, | |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| # See the License for the specific language governing permissions and | |
| # limitations under the License. | |
| """A wrapper script for J2ObjC transpiler. | |
| This script wraps around J2ObjC transpiler to also output a dependency mapping | |
| file by scanning the import and include directives of the J2ObjC-translated | |
| files. | |
| """ | |
| import argparse | |
| import multiprocessing | |
| import os | |
| import Queue | |
| import re | |
| import subprocess | |
| import tempfile | |
| import threading | |
| INCLUDE_RE = re.compile('#(include|import) "([^"]+)"') | |
| def RunJ2ObjC(java, jvm_flags, j2objc, main_class, j2objc_args): | |
| """Runs J2ObjC transpiler to translate Java source files to ObjC. | |
| Args: | |
| java: The path of the Java executable. | |
| jvm_flags: A comma-separated list of flags to pass to JVM. | |
| j2objc: The deploy jar of J2ObjC. | |
| main_class: The J2ObjC main class to invoke. | |
| j2objc_args: A list of args to pass to J2ObjC transpiler. | |
| Returns: | |
| None. | |
| """ | |
| source_files, flags = _ParseArgs(j2objc_args) | |
| source_file_manifest_content = ' '.join(source_files) | |
| fd = None | |
| param_filename = None | |
| try: | |
| fd, param_filename = tempfile.mkstemp(text=True) | |
| os.write(fd, source_file_manifest_content) | |
| finally: | |
| if fd: | |
| os.close(fd) | |
| try: | |
| j2objc_cmd = [java] | |
| j2objc_cmd.extend(filter(None, jvm_flags.split(','))) | |
| j2objc_cmd.extend(['-cp', j2objc, main_class]) | |
| j2objc_cmd.extend(flags) | |
| j2objc_cmd.extend(['@%s' % param_filename]) | |
| subprocess.check_call(j2objc_cmd, stderr=subprocess.STDOUT) | |
| finally: | |
| if param_filename: | |
| os.remove(param_filename) | |
| def WriteDepMappingFile(translated_source_files, | |
| objc_file_path, | |
| output_dependency_mapping_file, | |
| file_open=open): | |
| """Scans J2ObjC-translated files and outputs a dependency mapping file. | |
| The mapping file contains mappings between translated source files and their | |
| imported source files scanned from the import and include directives. | |
| Args: | |
| translated_source_files: A comma-separated list of files translated by | |
| J2ObjC. | |
| objc_file_path: The file path which represents a directory where the | |
| generated ObjC files reside. | |
| output_dependency_mapping_file: The path of the dependency mapping file to | |
| write to. | |
| file_open: Reference to the builtin open function so it may be | |
| overridden for testing. | |
| Raises: | |
| RuntimeError: If spawned threads throw errors during processing. | |
| Returns: | |
| None. | |
| """ | |
| dep_mapping = dict() | |
| input_file_queue = Queue.Queue() | |
| output_dep_mapping_queue = Queue.Queue() | |
| error_message_queue = Queue.Queue() | |
| for output_file in translated_source_files.split(','): | |
| input_file_queue.put(output_file) | |
| for _ in xrange(multiprocessing.cpu_count()): | |
| t = threading.Thread(target=_ReadDepMapping, args=(input_file_queue, | |
| output_dep_mapping_queue, | |
| error_message_queue, | |
| objc_file_path, | |
| file_open)) | |
| t.start() | |
| input_file_queue.join() | |
| if not error_message_queue.empty(): | |
| error_messages = [error_message for error_message in | |
| error_message_queue.queue] | |
| raise RuntimeError('\n'.join(error_messages)) | |
| while not output_dep_mapping_queue.empty(): | |
| entry_file, deps = output_dep_mapping_queue.get() | |
| dep_mapping[entry_file] = deps | |
| f = file_open(output_dependency_mapping_file, 'w') | |
| for entry in sorted(dep_mapping): | |
| for dep in dep_mapping[entry]: | |
| f.write(entry + ':' + dep + '\n') | |
| f.close() | |
| def _ReadDepMapping(input_file_queue, output_dep_mapping_queue, | |
| error_message_queue, objc_file_path, file_open=open): | |
| while True: | |
| try: | |
| input_file = input_file_queue.get_nowait() | |
| except Queue.Empty: | |
| # No more work left in the queue. | |
| return | |
| try: | |
| deps = [] | |
| entry = os.path.relpath(os.path.splitext(input_file)[0], objc_file_path) | |
| with file_open(input_file, 'r') as f: | |
| for line in f: | |
| include = INCLUDE_RE.match(line) | |
| if include: | |
| include_path = include.group(2) | |
| dep = os.path.splitext(include_path)[0] | |
| if dep != entry: | |
| deps.append(dep) | |
| output_dep_mapping_queue.put((entry, deps)) | |
| except Exception as e: # pylint: disable=broad-except | |
| error_message_queue.put(str(e)) | |
| finally: | |
| # We need to mark the task done to prevent blocking the main process | |
| # indefinitely. | |
| input_file_queue.task_done() | |
| def WriteArchiveSourceMappingFile(compiled_archive_file_path, | |
| output_archive_source_mapping_file, | |
| translated_source_files, | |
| objc_file_path, | |
| file_open=open): | |
| """Writes a mapping file between archive file to associated ObjC source files. | |
| Args: | |
| compiled_archive_file_path: The path of the archive file. | |
| output_archive_source_mapping_file: A path of the mapping file to write to. | |
| translated_source_files: A comma-separated list of source files translated | |
| by J2ObjC. | |
| objc_file_path: The file path which represents a directory where the | |
| generated ObjC files reside. | |
| file_open: Reference to the builtin open function so it may be | |
| overridden for testing. | |
| Returns: | |
| None. | |
| """ | |
| with file_open(output_archive_source_mapping_file, 'w') as f: | |
| for translated_source_file in translated_source_files.split(','): | |
| file_path = os.path.relpath(translated_source_file, objc_file_path) | |
| f.write(compiled_archive_file_path + ':' + file_path + '\n') | |
| def _ParseArgs(j2objc_args): | |
| """Separate arguments passed to J2ObjC into source files and J2ObjC flags. | |
| Args: | |
| j2objc_args: A list of args to pass to J2ObjC transpiler. | |
| Returns: | |
| A tuple containing source files and J2ObjC flags | |
| """ | |
| source_files = [] | |
| flags = [] | |
| is_next_flag_value = False | |
| for j2objc_arg in j2objc_args: | |
| if j2objc_arg.startswith('-'): | |
| flags.append(j2objc_arg) | |
| is_next_flag_value = True | |
| elif is_next_flag_value: | |
| flags.append(j2objc_arg) | |
| is_next_flag_value = False | |
| else: | |
| source_files.append(j2objc_arg) | |
| return (source_files, flags) | |
| if __name__ == '__main__': | |
| parser = argparse.ArgumentParser(fromfile_prefix_chars='@') | |
| parser.add_argument( | |
| '--java', | |
| required=True, | |
| help='The path to the Java executable.') | |
| parser.add_argument( | |
| '--jvm_flags', | |
| default='', | |
| help='A comma-separated list of flags to pass to the JVM.') | |
| parser.add_argument( | |
| '--j2objc', | |
| required=True, | |
| help='The path to the J2ObjC deploy jar.') | |
| parser.add_argument( | |
| '--main_class', | |
| required=True, | |
| help='The main class of the J2ObjC deploy jar to execute.') | |
| parser.add_argument( | |
| '--translated_source_files', | |
| required=True, | |
| help=('A comma-separated list of file paths where J2ObjC will write the ' | |
| 'translated files to.')) | |
| parser.add_argument( | |
| '--output_dependency_mapping_file', | |
| required=True, | |
| help='The file path of the dependency mapping file to write to.') | |
| parser.add_argument( | |
| '--objc_file_path', | |
| required=True, | |
| help=('The file path which represents a directory where the generated ' | |
| 'ObjC files reside.')) | |
| parser.add_argument( | |
| '--output_archive_source_mapping_file', | |
| help='The file path of the mapping file containing mappings between the ' | |
| 'translated source files and the to-be-generated archive file ' | |
| 'compiled from those source files. --compile_archive_file_path must ' | |
| 'be specified if this option is specified.') | |
| parser.add_argument( | |
| '--compiled_archive_file_path', | |
| required=False, | |
| help=('The archive file path that will be produced by ObjC compile action' | |
| ' later')) | |
| args, pass_through_args = parser.parse_known_args() | |
| RunJ2ObjC(args.java, | |
| args.jvm_flags, | |
| args.j2objc, | |
| args.main_class, | |
| pass_through_args) | |
| WriteDepMappingFile(args.translated_source_files, | |
| args.objc_file_path, | |
| args.output_dependency_mapping_file) | |
| if args.output_archive_source_mapping_file: | |
| WriteArchiveSourceMappingFile(args.compiled_archive_file_path, | |
| args.output_archive_source_mapping_file, | |
| args.translated_source_files, | |
| args.objc_file_path) |