| """ |
| Copyright 2024 Google LLC |
| SPDX-License-Identifier: MIT |
| """ |
| |
| from enum import Enum |
| |
| |
| class LibraryType(Enum): |
| Library = 0 # Default undefined library value |
| LibraryShared = 1 |
| LibraryStatic = 2 |
| |
| |
| class IncludeDirectories: |
| def __init__(self): |
| self.name: str = '' |
| self.dirs: list[str] = [] |
| self.visibility: list[str] = [] |
| |
| |
| class StaticLibrary(IncludeDirectories): |
| """ |
| Represents the cc_library_static / cc_library module in build files |
| """ |
| |
| def __init__(self): |
| """ |
| Attributes here favor a Soong attribute naming scheme |
| """ |
| super().__init__() |
| self.srcs: list[str] = [] |
| self.library_type: LibraryType = ( |
| LibraryType.Library |
| ) # Can be cc_library_static or cc_library_shared |
| # In Bazel, these headers are one merged list. |
| self.generated_headers: list[str] = [] |
| self.generated_sources: list[str] = [] |
| # In Bazel, these c options are copts |
| self.copts: list[str] = [] |
| self.cstd: str = '' |
| self.cpp_std: str = '' |
| self.conlyflags: list[str] = [] |
| self.cppflags: list[str] = [] |
| |
| self.deps: list[str] = [] |
| self.target_compatible_with: list[str] = [] |
| |
| self.local_include_dirs: list[str] = [] |
| self.system_include_dirs: list[str] = [] |
| self.static_libs: list[str] = [] |
| self.whole_static_libs: list[str] = [] |
| self.shared_libs: list[str] = [] |
| self.header_libs: list[str] = [] |
| |
| @property |
| def hdrs(self): |
| return self.generated_headers + self.generated_sources |
| |
| def __str__(self): |
| return f'@StaticLibrary: name: {self.name}, LibraryType: {self.library_type}' |
| |
| |
| class CustomTarget: |
| """ |
| Denoted as genrule in both build files |
| """ |
| |
| def __init__(self): |
| self.name: str = '' |
| self.srcs: list[str] = [] |
| self.out: list[str] = [] # 'outs' in bazel |
| self.tools: list[str] = [] |
| self.export_include_dirs: list[str] = [] |
| self.cmd: str = '' |
| |
| def __str__(self): |
| return ( |
| f'name: {self.name}\n' |
| f'srcs: {self.srcs}\n' |
| f'out: {self.out}\n' |
| f'tools: {self.tools}\n' |
| f'export_include_dirs: {self.export_include_dirs}\n' |
| f'cmd: {self.cmd}' |
| ) |
| |
| |
| class PythonCustomTarget(CustomTarget): |
| def __init__(self): |
| super().__init__() |
| self.main: str = '' |
| self.libs: list[str] = [] |
| self.imports: list[str] = [] |
| self.version = {} |
| |
| def __str__(self): |
| return ( |
| f'name: {self.name}\n' |
| f'main: {self.main}\n' |
| f'srcs: {self.srcs}\n' |
| f'libs: {self.libs}' |
| ) |
| |
| |
| class ProjectConfig: |
| """ |
| Class that represents a singular project_config within aosp.toml/fuchsia.toml |
| in python objects. There are multiple project_config within each .toml |
| file |
| """ |
| def __init__(self): |
| self._build: str = '' # Global across all configs |
| self._name: str = '' # name of this config |
| self._inherits_from = '' |
| # project_config.host_machine |
| self._cpu_family: str = '' |
| self._cpu: str = '' |
| self._host_machine: str = '' |
| self._build_machine: str = '' |
| # project_config.meson_options |
| self._meson_options: dict[str, int | str] = {} |
| # project_config.header_not_supported |
| self._headers_not_supported: list[str] = [] |
| # project_config.symbol_not_supported |
| self._symbols_not_supported: list[str] = [] |
| # project_config.function_not_supported |
| self._functions_not_supported: list[str] = [] |
| # project_config.link_not_supported |
| self._links_not_supported: list[str] = [] |
| # project_config.ext_dependencies |
| self._ext_dependencies: dict[str, list[dict[str, str | int]]] = {} |
| # Example structure for ext_dependencies |
| # { |
| # zlib = [ |
| # { |
| # 'target_name': '@zlib//:zlib', |
| # 'target_type': 2 |
| # }, |
| # ... |
| # ] |
| |
| @staticmethod |
| def create_project_config(build, **kwargs): |
| project_config = ProjectConfig() |
| project_config._build = build # Global across all configs |
| project_config._name = kwargs.get('name') # name of this config |
| project_config._inherits_from = kwargs.get('inherits_from') |
| project_config._cpu_family = kwargs.get('host_machine').get('cpu_family') |
| project_config._cpu = kwargs.get('host_machine').get('cpu') |
| project_config._host_machine = kwargs.get('host_machine').get('host_machine') |
| project_config._build_machine = kwargs.get('host_machine').get('build_machine') |
| project_config._meson_options = kwargs.get('meson_options') |
| project_config._headers_not_supported = kwargs.get('header_not_supported').get( |
| 'headers' |
| ) |
| project_config._symbols_not_supported = kwargs.get('symbol_not_supported').get( |
| 'symbols' |
| ) |
| project_config._functions_not_supported = kwargs.get( |
| 'function_not_supported' |
| ).get('functions') |
| project_config._links_not_supported = kwargs.get('link_not_supported').get( |
| 'links' |
| ) |
| project_config._ext_dependencies = kwargs.get('ext_dependencies') |
| return project_config |
| |
| def extend(self, proj_config): |
| """ |
| Appends to the current instance of ProjectConfig with another |
| This also overrides attributes like self._name to the given param |
| :param proj_config: ProjectConfig |
| :return: ProjectConfig |
| """ |
| self._build = proj_config.build |
| self._name = proj_config.name |
| self._inherits_from = proj_config.inherits_from |
| self._cpu_family = proj_config.cpu_family |
| self._cpu = proj_config.cpu |
| self._host_machine = proj_config.host_machine |
| self._build_machine = proj_config.build_machine |
| |
| self._meson_options.update(proj_config.meson_options) |
| self._headers_not_supported.extend(proj_config.headers_not_supported) |
| self._symbols_not_supported.extend(proj_config.symbols_not_supported) |
| self._functions_not_supported.extend(proj_config.functions_not_supported) |
| self._links_not_supported.extend(proj_config.links_not_supported) |
| self._ext_dependencies.update(proj_config.ext_dependencies) |
| return self |
| |
| def deepcopy(self): |
| proj = ProjectConfig() |
| proj._build = self._build |
| proj._name = self._name |
| proj._inherits_from = self._inherits_from |
| proj._cpu_family = self._cpu_family |
| proj._cpu = self._cpu |
| proj._host_machine = self._host_machine |
| proj._build_machine = self._build_machine |
| |
| proj._meson_options.update(self._meson_options) |
| proj._headers_not_supported.extend(self._headers_not_supported) |
| proj._symbols_not_supported.extend(self._symbols_not_supported) |
| proj._functions_not_supported.extend(self._functions_not_supported) |
| proj._links_not_supported.extend(self._links_not_supported) |
| proj._ext_dependencies.update(self._ext_dependencies) |
| return proj |
| |
| @property |
| def build(self): |
| return self._build |
| |
| @property |
| def name(self): |
| return self._name |
| |
| @property |
| def inherits_from(self): |
| return self._inherits_from |
| |
| @property |
| def cpu(self): |
| return self._cpu |
| |
| @property |
| def cpu_family(self): |
| return self._cpu_family |
| |
| @property |
| def host_machine(self): |
| return self._host_machine |
| |
| @property |
| def build_machine(self): |
| return self._build_machine |
| |
| @property |
| def meson_options(self): |
| return self._meson_options |
| |
| @property |
| def headers_not_supported(self): |
| return self._headers_not_supported |
| |
| @property |
| def symbols_not_supported(self): |
| return self._symbols_not_supported |
| |
| @property |
| def functions_not_supported(self): |
| return self._functions_not_supported |
| |
| @property |
| def links_not_supported(self): |
| return self._links_not_supported |
| |
| @property |
| def ext_dependencies(self): |
| return self._ext_dependencies |
| |
| def __str__(self): |
| return f""" |
| @ProjectConfig: {self._name} |
| inherits_from: {self._inherits_from} |
| build: {self._build} |
| cpu_family: {self._cpu_family} |
| cpu: {self._cpu} |
| host_machine: {self._host_machine} |
| build_machine: {self._build_machine} |
| meson_options: {self._meson_options} |
| headers_not_supported: {self._headers_not_supported} |
| symbols_not_supported: {self._symbols_not_supported} |
| functions_not_supported: {self._functions_not_supported} |
| links_not_supported: {self._links_not_supported} |
| ext_dependencies: {self._ext_dependencies} |
| """ |
| |
| |
| class MesonProjectState: |
| """ |
| Represents a singular build config |
| """ |
| |
| def __init__(self): |
| self.static_libraries: list[StaticLibrary] = [] |
| self.custom_targets: list[CustomTarget] = [] |
| self.custom_py_targets: list[PythonCustomTarget] = [] |
| self.include_dirs: list[IncludeDirectories] = [] |
| |
| def __str__(self): |
| return ( |
| f'static libraries len: {len(self.static_libraries)}\n' |
| f'custom targets len: {len(self.custom_targets)}\n' |
| f'custom py targets len: {len(self.custom_py_targets)}\n' |
| f'include dirs len: {len(self.include_dirs)}\n' |
| ) |
