def link_executable_using_cache(file_system: FileSystem, compiler: Compiler, executables_root: str, symbols_tables_root: str, external_libraries_root: str, external_libraries_interfaces_root: str, objects: List[str], external_libraries: List[str], external_libraries_interfaces: List[str], organization: str, artifact: str, version: str, cache: Dict[str, Any], is_test: bool = False) -> Tuple[str, str]: file_system.create_directory_if_missing(executables_root) file_system.create_directory_if_missing(symbols_tables_root) name = get_artifact_full_name( organization, artifact, compiler.get_architecture(), compiler.get_platform(), compiler.get_name(), compiler.get_mode(), version) + ('.test' if is_test else '') cache['input'] = input_ = cache.get('input', {}) (old_executable, old_symbols_table) = cache.get('output', (None, None)) hasher = lambda path: hash_file(file_system, path) updated, removed, new_cache = key_delta( objects + external_libraries + external_libraries_interfaces, hasher, input_) yield_descriptor = compiler.get_yield_descriptor() executable = yield_descriptor.get_executable(executables_root, name) symbols_table = yield_descriptor.get_symbols_table(symbols_tables_root, name) remake_executable = executable and not file_system.exists(executable) remake_symbols_table = symbols_table and not file_system.exists( symbols_table) if updated or removed or remake_executable or remake_symbols_table: if old_executable and file_system.exists(old_executable): file_system.remove_file(old_executable) if old_symbols_table and file_system.exists(old_symbols_table): file_system.remove_file(old_symbols_table) compiler.link_executable(external_libraries_root, external_libraries_interfaces_root, objects, external_libraries, external_libraries_interfaces, executable, symbols_table) cache['input'] = new_cache cache['output'] = (executable, symbols_table) return (executable, symbols_table)
def validate_project(file_system: FileSystem, resources: StageResources, cache: Dict[str, Any], program_arguments: Dict[str, Any], configuration: Dict[str, Any], remote_proxy: RemoteProxy): project_directory = resources['project_directory'] resources['headers_root'] = join(project_directory, 'sources') resources['test_sources_root'] = join(project_directory, 'sources') resources['resources_root'] = resources_root = join( project_directory, 'resources') resources['main_sources_root'] = main_sources_root = join( project_directory, 'sources') pralinefile = resources['pralinefile'] organization = pralinefile['organization'] artifact = pralinefile['artifact'] file_system.create_directory_if_missing( join(resources_root, organization, artifact)) file_system.create_directory_if_missing( join(main_sources_root, organization, artifact)) check_unique(file_system, resources_root, organization, artifact) check_unique(file_system, main_sources_root, organization, artifact)
def compile_using_cache(file_system: FileSystem, compiler: Compiler, headers_root: str, external_headers_root: str, sources_root: str, objects_root: str, headers: List[str], sources: List[str], cache: Dict[str, Any]) -> List[str]: file_system.create_directory_if_missing(objects_root) def hash_translation_unit(source): return hash_binary( compiler.preprocess(headers_root, external_headers_root, headers, source)) updated, removed, new_cache = key_delta(sources, hash_translation_unit, cache) objects = [] yield_descriptor = compiler.get_yield_descriptor() for source in updated: object_ = yield_descriptor.get_object(sources_root, objects_root, source) compiler.compile(headers_root, external_headers_root, headers, source, object_) for source in removed: object_ = yield_descriptor.get_object(sources_root, objects_root, source) if file_system.exists(object_): file_system.remove_file(object_) for source in sources: object_ = yield_descriptor.get_object(sources_root, objects_root, source) if not file_system.exists(object_): compiler.compile(headers_root, external_headers_root, headers, source, object_) objects.append(object_) cache.clear() cache.update(new_cache) return objects
def package_headers_only(file_system: FileSystem, resources: StageResources, cache: Dict[str, Any], program_arguments: Dict[str, Any], configuration: Dict[str, Any], remote_proxy: RemoteProxy): project_directory = resources['project_directory'] pralinefile = resources['pralinefile'] compiler = resources['compiler'] resources_root = resources['resources_root'] resource_files = resources['resources'] headers_root = resources['headers_root'] if resources.activation in [0, 1]: headers = resources['formatted_headers'] elif resources.activation in [2, 3]: headers = resources['headers'] package_path = join( project_directory, 'target', get_package(pralinefile['organization'], pralinefile['artifact'], compiler.get_architecture(), compiler.get_platform(), compiler.get_name(), compiler.get_mode(), pralinefile['version'])) file_system.create_directory_if_missing(join(project_directory, 'target')) package_files = [(path, join('resources', relative_path(path, resources_root))) for path in resource_files] package_files.extend( (path, join('headers', relative_path(path, headers_root))) for path in headers) package_files.append((join(project_directory, 'Pralinefile'), 'Pralinefile')) pack(file_system, package_path, package_files, cache) resources['headers_only_package'] = package_path
def pull_dependencies(file_system: FileSystem, resources: StageResources, cache: Dict[str, Any], program_arguments: Dict[str, Any], configuration: Dict[str, Any], remote_proxy: RemoteProxy): project_directory = resources['project_directory'] external_root = join(project_directory, 'target', 'external') external_packages_root = join(external_root, 'packages') resources['external_resources_root'] = external_resources_root = join(external_root, 'resources') resources['external_headers_root'] = external_headers_root = join(external_root, 'headers') resources['external_executables_root'] = external_executables_root = join(external_root, 'executables') resources['external_libraries_root'] = external_libraries_root = join(external_root, 'libraries') resources['external_libraries_interfaces_root'] = external_libraries_interfaces_root = join(external_root, 'libraries_interfaces') resources['external_symbols_tables_root'] = external_symbols_tables_root = join(external_root, 'symbols_tables') file_system.create_directory_if_missing(external_packages_root) file_system.create_directory_if_missing(external_resources_root) file_system.create_directory_if_missing(external_headers_root) file_system.create_directory_if_missing(external_executables_root) file_system.create_directory_if_missing(external_libraries_root) file_system.create_directory_if_missing(external_libraries_interfaces_root) file_system.create_directory_if_missing(external_symbols_tables_root) external_resources = [] external_headers = [] external_libraries = [] external_libraries_interfaces = [] external_symbols_tables = [] external_executables = [] def extend_externals(contents): external_resources.extend(contents['resources']) external_headers.extend(contents['headers']) external_libraries.extend(contents['libraries']) external_libraries_interfaces.extend(contents['libraries_interfaces']) external_symbols_tables.extend(contents['symbols_tables']) external_executables.extend(contents['executables']) pralinefile = resources['pralinefile'] compiler = resources['compiler'] logging_level = program_arguments['global']['logging_level'] packages = remote_proxy.solve_dependencies(pralinefile, compiler.get_architecture(), compiler.get_platform(), compiler.get_name(), compiler.get_mode()) updated, removed, new_cache = key_delta(packages.keys(), lambda p: packages[p], cache) for package in removed: package_path = join(external_packages_root, package) clean_up_package(file_system, package_path, external_root, logging_level) for package in updated: package_path = join(external_packages_root, package) clean_up_package(file_system, package_path, external_root, logging_level) remote_proxy.pull_package(package_path) contents = unpack(file_system, package_path, external_root) extend_externals(contents) for package in packages: if package not in updated: package_path = join(external_packages_root, package) if not file_system.exists(package_path): remote_proxy.pull_package(package_path) contents = unpack(file_system, package_path, external_root) else: contents = get_package_extracted_contents(file_system, package_path, external_root) extend_externals(contents) resources['external_resources'] = external_resources resources['external_headers'] = external_headers resources['external_libraries'] = external_libraries resources['external_libraries_interfaces'] = external_libraries_interfaces resources['external_symbols_tables'] = external_symbols_tables resources['external_executables'] = external_executables cache.clear() cache.update(new_cache)