| #!/usr/bin/env python3 |
| # |
| # Copyright 2019 - The Android Open Source Project |
| # |
| # 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. |
| |
| """It is an AIDEGen sub task: generate the CLion project file. |
| |
| Usage example: |
| json_path = common_util.get_blueprint_json_path( |
| constant.BLUEPRINT_CC_JSONFILE_NAME) |
| json_dict = common_util.get_soong_build_json_dict(json_path) |
| if 'modules' not in json_dict: |
| return |
| mod_info = json_dict['modules'].get('libui', {}) |
| if not mod_info: |
| return |
| CLionProjectFileGenerator(mod_info).generate_cmakelists_file() |
| """ |
| |
| import logging |
| import os |
| |
| from io import StringIO |
| from io import TextIOWrapper |
| |
| from aidegen import constant |
| from aidegen import templates |
| from aidegen.lib import common_util |
| from aidegen.lib import errors |
| from aidegen.lib import native_module_info |
| |
| # Flags for writing to CMakeLists.txt section. |
| _GLOBAL_COMMON_FLAGS = '\n# GLOBAL ALL FLAGS:\n' |
| _LOCAL_COMMON_FLAGS = '\n# LOCAL ALL FLAGS:\n' |
| _GLOBAL_CFLAGS = '\n# GLOBAL CFLAGS:\n' |
| _LOCAL_CFLAGS = '\n# LOCAL CFLAGS:\n' |
| _GLOBAL_C_ONLY_FLAGS = '\n# GLOBAL C ONLY FLAGS:\n' |
| _LOCAL_C_ONLY_FLAGS = '\n# LOCAL C ONLY FLAGS:\n' |
| _GLOBAL_CPP_FLAGS = '\n# GLOBAL CPP FLAGS:\n' |
| _LOCAL_CPP_FLAGS = '\n# LOCAL CPP FLAGS:\n' |
| _SYSTEM_INCLUDE_FLAGS = '\n# GLOBAL SYSTEM INCLUDE FLAGS:\n' |
| |
| # Keys for writing in module_bp_cc_deps.json |
| _KEY_GLOBAL_COMMON_FLAGS = 'global_common_flags' |
| _KEY_LOCAL_COMMON_FLAGS = 'local_common_flags' |
| _KEY_GLOBAL_CFLAGS = 'global_c_flags' |
| _KEY_LOCAL_CFLAGS = 'local_c_flags' |
| _KEY_GLOBAL_C_ONLY_FLAGS = 'global_c_only_flags' |
| _KEY_LOCAL_C_ONLY_FLAGS = 'local_c_only_flags' |
| _KEY_GLOBAL_CPP_FLAGS = 'global_cpp_flags' |
| _KEY_LOCAL_CPP_FLAGS = 'local_cpp_flags' |
| _KEY_SYSTEM_INCLUDE_FLAGS = 'system_include_flags' |
| |
| # Dictionary maps keys to sections. |
| _FLAGS_DICT = { |
| _KEY_GLOBAL_COMMON_FLAGS: _GLOBAL_COMMON_FLAGS, |
| _KEY_LOCAL_COMMON_FLAGS: _LOCAL_COMMON_FLAGS, |
| _KEY_GLOBAL_CFLAGS: _GLOBAL_CFLAGS, |
| _KEY_LOCAL_CFLAGS: _LOCAL_CFLAGS, |
| _KEY_GLOBAL_C_ONLY_FLAGS: _GLOBAL_C_ONLY_FLAGS, |
| _KEY_LOCAL_C_ONLY_FLAGS: _LOCAL_C_ONLY_FLAGS, |
| _KEY_GLOBAL_CPP_FLAGS: _GLOBAL_CPP_FLAGS, |
| _KEY_LOCAL_CPP_FLAGS: _LOCAL_CPP_FLAGS, |
| _KEY_SYSTEM_INCLUDE_FLAGS: _SYSTEM_INCLUDE_FLAGS |
| } |
| |
| # Keys for parameter types. |
| _KEY_FLAG = 'flag' |
| _KEY_SYSTEM_ROOT = 'system_root' |
| _KEY_RELATIVE = 'relative_file_path' |
| |
| # Constants for CMakeLists.txt. |
| _MIN_VERSION_TOKEN = '@MINVERSION@' |
| _PROJECT_NAME_TOKEN = '@PROJNAME@' |
| _ANDROID_ROOT_TOKEN = '@ANDROIDROOT@' |
| _MINI_VERSION_SUPPORT = 'cmake_minimum_required(VERSION {})\n' |
| _MINI_VERSION = '3.5' |
| _KEY_CLANG = 'clang' |
| _KEY_CPPLANG = 'clang++' |
| _SET_C_COMPILER = 'set(CMAKE_C_COMPILER \"{}\")\n' |
| _SET_CXX_COMPILER = 'set(CMAKE_CXX_COMPILER \"{}\")\n' |
| _LIST_APPEND_HEADER = 'list(APPEND\n' |
| _SOURCE_FILES_HEADER = 'SOURCE_FILES' |
| _SOURCE_FILES_LINE = ' SOURCE_FILES\n' |
| _END_WITH_ONE_BLANK_LINE = ')\n' |
| _END_WITH_TWO_BLANK_LINES = ')\n\n' |
| _SET_RELATIVE_PATH = 'set({} "{} {}={}")\n' |
| _SET_ALL_FLAGS = 'set({} "{} {}")\n' |
| _ANDROID_ROOT_SYMBOL = '${ANDROID_ROOT}' |
| _SYSTEM = 'SYSTEM' |
| _INCLUDE_DIR = 'include_directories({} \n' |
| _SET_INCLUDE_FORMAT = ' "{}"\n' |
| _CMAKE_C_FLAGS = 'CMAKE_C_FLAGS' |
| _CMAKE_CXX_FLAGS = 'CMAKE_CXX_FLAGS' |
| _USR = 'usr' |
| _INCLUDE = 'include' |
| _INCLUDE_SYSTEM = 'include_directories(SYSTEM "{}")\n' |
| _GLOB_RECURSE_TMP_HEADERS = 'file (GLOB_RECURSE TMP_HEADERS\n' |
| _ALL_HEADER_FILES = ' "{}/**/*.h"\n' |
| _APPEND_SOURCE_FILES = "list (APPEND SOURCE_FILES ${TMP_HEADERS})\n\n" |
| _ADD_EXECUTABLE_HEADER = '\nadd_executable({} {})' |
| _PROJECT = 'project({})\n' |
| _ADD_SUB = 'add_subdirectory({})\n' |
| _DICT_EMPTY = 'mod_info is empty.' |
| _DICT_NO_MOD_NAME_KEY = "mod_info does not contain 'module_name' key." |
| _DICT_NO_PATH_KEY = "mod_info does not contain 'path' key." |
| _MODULE_INFO_EMPTY = 'The module info dictionary is empty.' |
| |
| |
| class CLionProjectFileGenerator: |
| """CLion project file generator. |
| |
| Attributes: |
| mod_info: A dictionary of the target module's info. |
| mod_name: A string of module name. |
| mod_path: A string of module's path. |
| cc_dir: A string of generated CLion project file's directory. |
| cc_path: A string of generated CLion project file's path. |
| """ |
| |
| def __init__(self, mod_info, parent_dir=None): |
| """ProjectFileGenerator initialize. |
| |
| Args: |
| mod_info: A dictionary of native module's info. |
| parent_dir: The parent directory of this native module. The default |
| value is None. |
| """ |
| if not mod_info: |
| raise errors.ModuleInfoEmptyError(_MODULE_INFO_EMPTY) |
| self.mod_info = mod_info |
| self.mod_name = self._get_module_name() |
| self.mod_path = CLionProjectFileGenerator.get_module_path( |
| mod_info, parent_dir) |
| self.cc_dir = CLionProjectFileGenerator.get_cmakelists_file_dir( |
| os.path.join(self.mod_path, self.mod_name)) |
| if not os.path.exists(self.cc_dir): |
| os.makedirs(self.cc_dir) |
| self.cc_path = os.path.join(self.cc_dir, |
| constant.CLION_PROJECT_FILE_NAME) |
| |
| def _get_module_name(self): |
| """Gets the value of the 'module_name' key if it exists. |
| |
| Returns: |
| A string of the module's name. |
| |
| Raises: |
| NoModuleNameDefinedInModuleInfoError if no 'module_name' key in |
| mod_info. |
| """ |
| mod_name = self.mod_info.get(constant.KEY_MODULE_NAME, '') |
| if not mod_name: |
| raise errors.NoModuleNameDefinedInModuleInfoError( |
| _DICT_NO_MOD_NAME_KEY) |
| return mod_name |
| |
| @staticmethod |
| def get_module_path(mod_info, parent_dir=None): |
| """Gets the correct value of the 'path' key if it exists. |
| |
| When a module with different paths, e.g., |
| 'libqcomvoiceprocessingdescriptors': { |
| 'path': [ |
| 'device/google/bonito/voice_processing', |
| 'device/google/coral/voice_processing', |
| 'device/google/crosshatch/voice_processing', |
| 'device/google/muskie/voice_processing', |
| 'device/google/taimen/voice_processing' |
| ], |
| ... |
| } |
| it might be wrong if we always choose the first path. For example, in |
| this case if users command 'aidegen -i c device/google/coral' the |
| correct path they need should be the second one. |
| |
| Args: |
| mod_info: A module's info dictionary. |
| parent_dir: The parent directory of this native module. The default |
| value is None. |
| |
| Returns: |
| A string of the module's path. |
| |
| Raises: |
| NoPathDefinedInModuleInfoError if no 'path' key in mod_info. |
| """ |
| mod_paths = mod_info.get(constant.KEY_PATH, []) |
| if not mod_paths: |
| raise errors.NoPathDefinedInModuleInfoError(_DICT_NO_PATH_KEY) |
| mod_path = mod_paths[0] |
| if parent_dir and len(mod_paths) > 1: |
| for path in mod_paths: |
| if common_util.is_source_under_relative_path(path, parent_dir): |
| mod_path = path |
| return mod_path |
| |
| @staticmethod |
| @common_util.check_args(cc_path=str) |
| def get_cmakelists_file_dir(cc_path): |
| """Gets module's CMakeLists.txt file path to be created. |
| |
| Return a string of $OUT/development/ide/clion/${cc_path}. |
| For example, if module name is 'libui'. The return path string would be: |
| out/development/ide/clion/frameworks/native/libs/ui/libui |
| |
| Args: |
| cc_path: A string of absolute path of module's Android.bp file. |
| |
| Returns: |
| A string of absolute path of module's CMakeLists.txt file to be |
| created. |
| """ |
| return os.path.join(common_util.get_android_root_dir(), |
| common_util.get_android_out_dir(), |
| constant.RELATIVE_NATIVE_PATH, cc_path) |
| |
| def generate_cmakelists_file(self): |
| """Generates CLion project file from the target module's info.""" |
| with open(self.cc_path, 'w', encoding='utf-8') as hfile: |
| self._write_cmakelists_file(hfile) |
| |
| @common_util.check_args(hfile=(TextIOWrapper, StringIO)) |
| @common_util.io_error_handle |
| def _write_cmakelists_file(self, hfile): |
| """Writes CLion project file content with necessary info. |
| |
| Args: |
| hfile: A file handler instance. |
| """ |
| self._write_header(hfile) |
| self._write_c_compiler_paths(hfile) |
| self._write_source_files(hfile) |
| self._write_cmakelists_flags(hfile) |
| self._write_tail(hfile) |
| |
| @common_util.check_args(hfile=(TextIOWrapper, StringIO)) |
| @common_util.io_error_handle |
| def _write_header(self, hfile): |
| """Writes CLion project file's header messages. |
| |
| Args: |
| hfile: A file handler instance. |
| """ |
| content = templates.CMAKELISTS_HEADER.replace( |
| _MIN_VERSION_TOKEN, _MINI_VERSION) |
| content = content.replace(_PROJECT_NAME_TOKEN, self.mod_name) |
| content = content.replace( |
| _ANDROID_ROOT_TOKEN, common_util.get_android_root_dir()) |
| hfile.write(content) |
| |
| @common_util.check_args(hfile=(TextIOWrapper, StringIO)) |
| @common_util.io_error_handle |
| def _write_c_compiler_paths(self, hfile): |
| """Writes CMake compiler paths for C and Cpp to CLion project file. |
| |
| Args: |
| hfile: A file handler instance. |
| """ |
| hfile.write(_SET_C_COMPILER.format( |
| native_module_info.NativeModuleInfo.c_lang_path)) |
| hfile.write(_SET_CXX_COMPILER.format( |
| native_module_info.NativeModuleInfo.cpp_lang_path)) |
| |
| @common_util.check_args(hfile=(TextIOWrapper, StringIO)) |
| @common_util.io_error_handle |
| def _write_source_files(self, hfile): |
| """Writes source files' paths to CLion project file. |
| |
| Args: |
| hfile: A file handler instance. |
| """ |
| if constant.KEY_SRCS not in self.mod_info: |
| logging.warning("No source files in %s's module info.", |
| self.mod_name) |
| return |
| root = common_util.get_android_root_dir() |
| source_files = self.mod_info[constant.KEY_SRCS] |
| hfile.write(_LIST_APPEND_HEADER) |
| hfile.write(_SOURCE_FILES_LINE) |
| for src in source_files: |
| if not os.path.exists(os.path.join(root, src)): |
| continue |
| hfile.write(''.join([_build_cmake_path(src, ' '), '\n'])) |
| hfile.write(_END_WITH_ONE_BLANK_LINE) |
| |
| @common_util.check_args(hfile=(TextIOWrapper, StringIO)) |
| @common_util.io_error_handle |
| def _write_cmakelists_flags(self, hfile): |
| """Writes all kinds of flags in CLion project file. |
| |
| Args: |
| hfile: A file handler instance. |
| """ |
| self._write_flags(hfile, _KEY_GLOBAL_COMMON_FLAGS, True, True) |
| self._write_flags(hfile, _KEY_LOCAL_COMMON_FLAGS, True, True) |
| self._write_flags(hfile, _KEY_GLOBAL_CFLAGS, True, True) |
| self._write_flags(hfile, _KEY_LOCAL_CFLAGS, True, True) |
| self._write_flags(hfile, _KEY_GLOBAL_C_ONLY_FLAGS, True, False) |
| self._write_flags(hfile, _KEY_LOCAL_C_ONLY_FLAGS, True, False) |
| self._write_flags(hfile, _KEY_GLOBAL_CPP_FLAGS, False, True) |
| self._write_flags(hfile, _KEY_LOCAL_CPP_FLAGS, False, True) |
| self._write_flags(hfile, _KEY_SYSTEM_INCLUDE_FLAGS, True, True) |
| |
| @common_util.check_args(hfile=(TextIOWrapper, StringIO)) |
| @common_util.io_error_handle |
| def _write_tail(self, hfile): |
| """Writes CLion project file content with necessary info. |
| |
| Args: |
| hfile: A file handler instance. |
| """ |
| hfile.write( |
| _ADD_EXECUTABLE_HEADER.format( |
| _cleanup_executable_name(self.mod_name), |
| _add_dollar_sign(_SOURCE_FILES_HEADER))) |
| |
| @common_util.check_args( |
| hfile=(TextIOWrapper, StringIO), key=str, cflags=bool, cppflags=bool) |
| @common_util.io_error_handle |
| def _write_flags(self, hfile, key, cflags, cppflags): |
| """Writes CMake compiler paths of C, Cpp for different kinds of flags. |
| |
| Args: |
| hfile: A file handler instance. |
| key: A string of flag type, e.g., 'global_common_flags' flag. |
| cflags: A boolean for setting 'CMAKE_C_FLAGS' flag. |
| cppflags: A boolean for setting 'CMAKE_CXX_FLAGS' flag. |
| """ |
| if key not in _FLAGS_DICT: |
| return |
| hfile.write(_FLAGS_DICT[key]) |
| params_dict = self._parse_compiler_parameters(key) |
| if params_dict: |
| _translate_to_cmake(hfile, params_dict, cflags, cppflags) |
| |
| @common_util.check_args(flag=str) |
| def _parse_compiler_parameters(self, flag): |
| """Parses the specific flag data from a module_info dictionary. |
| |
| Args: |
| flag: The string of key flag, e.g.: _KEY_GLOBAL_COMMON_FLAGS. |
| |
| Returns: |
| A dictionary with compiled parameters. |
| """ |
| params = self.mod_info.get(flag, {}) |
| if not params: |
| return None |
| params_dict = { |
| constant.KEY_HEADER: [], |
| constant.KEY_SYSTEM: [], |
| _KEY_FLAG: [], |
| _KEY_SYSTEM_ROOT: '', |
| _KEY_RELATIVE: {} |
| } |
| for key, value in params.items(): |
| params_dict[key] = value |
| return params_dict |
| |
| |
| @common_util.check_args(rel_project_path=str, mod_names=list) |
| @common_util.io_error_handle |
| def generate_base_cmakelists_file(cc_module_info, rel_project_path, mod_names): |
| """Generates base CLion project file for multiple CLion projects. |
| |
| We create a multiple native project file: |
| {android_root}/development/ide/clion/{rel_project_path}/CMakeLists.txt |
| and use this project file to generate a link: |
| {android_root}/out/development/ide/clion/{rel_project_path}/CMakeLists.txt |
| |
| Args: |
| cc_module_info: An instance of native_module_info.NativeModuleInfo. |
| rel_project_path: A string of the base project relative path. For |
| example: frameworks/native/libs/ui. |
| mod_names: A list of module names whose project were created under |
| rel_project_path. |
| |
| Returns: |
| A symbolic link CLion project file path. |
| """ |
| root_dir = common_util.get_android_root_dir() |
| cc_dir = os.path.join(root_dir, constant.RELATIVE_NATIVE_PATH, |
| rel_project_path) |
| cc_out_dir = os.path.join(root_dir, common_util.get_android_out_dir(), |
| constant.RELATIVE_NATIVE_PATH, rel_project_path) |
| if not os.path.exists(cc_dir): |
| os.makedirs(cc_dir) |
| dst_path = os.path.join(cc_out_dir, constant.CLION_PROJECT_FILE_NAME) |
| if os.path.islink(dst_path): |
| os.unlink(dst_path) |
| src_path = os.path.join(cc_dir, constant.CLION_PROJECT_FILE_NAME) |
| if os.path.isfile(src_path): |
| os.remove(src_path) |
| with open(src_path, 'w', encoding='utf-8') as hfile: |
| _write_base_cmakelists_file(hfile, cc_module_info, src_path, mod_names) |
| os.symlink(src_path, dst_path) |
| return dst_path |
| |
| |
| @common_util.check_args( |
| hfile=(TextIOWrapper, StringIO), abs_project_path=str, mod_names=list) |
| @common_util.io_error_handle |
| def _write_base_cmakelists_file(hfile, cc_module_info, abs_project_path, |
| mod_names): |
| """Writes base CLion project file content. |
| |
| When we write module info into base CLion project file, first check if the |
| module's CMakeLists.txt exists. If file exists, write content, |
| add_subdirectory({'relative_module_path'}) |
| |
| Args: |
| hfile: A file handler instance. |
| cc_module_info: An instance of native_module_info.NativeModuleInfo. |
| abs_project_path: A string of the base project absolute path. |
| For example, |
| ${ANDROID_BUILD_TOP}/frameworks/native/libs/ui. |
| mod_names: A list of module names whose project were created under |
| abs_project_path. |
| """ |
| hfile.write(_MINI_VERSION_SUPPORT.format(_MINI_VERSION)) |
| project_dir = os.path.dirname(abs_project_path) |
| hfile.write(_PROJECT.format(os.path.basename(project_dir))) |
| root_dir = common_util.get_android_root_dir() |
| parent_dir = os.path.relpath(abs_project_path, root_dir) |
| for mod_name in mod_names: |
| mod_info = cc_module_info.get_module_info(mod_name) |
| mod_path = CLionProjectFileGenerator.get_module_path( |
| mod_info, parent_dir) |
| file_dir = CLionProjectFileGenerator.get_cmakelists_file_dir( |
| os.path.join(mod_path, mod_name)) |
| file_path = os.path.join(file_dir, constant.CLION_PROJECT_FILE_NAME) |
| if not os.path.isfile(file_path): |
| logging.warning("%s the project file %s doesn't exist.", |
| common_util.COLORED_INFO('Warning:'), file_path) |
| continue |
| link_project_dir = os.path.join(root_dir, |
| common_util.get_android_out_dir(), |
| os.path.relpath(project_dir, root_dir)) |
| rel_mod_path = os.path.relpath(file_dir, link_project_dir) |
| hfile.write(_ADD_SUB.format(rel_mod_path)) |
| |
| |
| @common_util.check_args( |
| hfile=(TextIOWrapper, StringIO), params_dict=dict, cflags=bool, |
| cppflags=bool) |
| def _translate_to_cmake(hfile, params_dict, cflags, cppflags): |
| """Translates parameter dict's contents into CLion project file format. |
| |
| Args: |
| hfile: A file handler instance. |
| params_dict: A dict contains data to be translated into CLion |
| project file format. |
| cflags: A boolean is to set 'CMAKE_C_FLAGS' flag. |
| cppflags: A boolean is to set 'CMAKE_CXX_FLAGS' flag. |
| """ |
| _write_all_include_directories( |
| hfile, params_dict[constant.KEY_SYSTEM], True) |
| _write_all_include_directories( |
| hfile, params_dict[constant.KEY_HEADER], False) |
| |
| if cflags: |
| _write_all_relative_file_path_flags(hfile, params_dict[_KEY_RELATIVE], |
| _CMAKE_C_FLAGS) |
| _write_all_flags(hfile, params_dict[_KEY_FLAG], _CMAKE_C_FLAGS) |
| |
| if cppflags: |
| _write_all_relative_file_path_flags(hfile, params_dict[_KEY_RELATIVE], |
| _CMAKE_CXX_FLAGS) |
| _write_all_flags(hfile, params_dict[_KEY_FLAG], _CMAKE_CXX_FLAGS) |
| |
| if params_dict[_KEY_SYSTEM_ROOT]: |
| path = os.path.join(params_dict[_KEY_SYSTEM_ROOT], _USR, _INCLUDE) |
| hfile.write(_INCLUDE_SYSTEM.format(_build_cmake_path(path))) |
| |
| |
| @common_util.check_args(hfile=(TextIOWrapper, StringIO), is_system=bool) |
| @common_util.io_error_handle |
| def _write_all_include_directories(hfile, includes, is_system): |
| """Writes all included directories' paths to the CLion project file. |
| |
| Args: |
| hfile: A file handler instance. |
| includes: A list of included file paths. |
| is_system: A boolean of whether it's a system flag. |
| """ |
| if not includes: |
| return |
| _write_all_includes(hfile, includes, is_system) |
| _write_all_headers(hfile, includes) |
| |
| |
| @common_util.check_args( |
| hfile=(TextIOWrapper, StringIO), rel_paths_dict=dict, tag=str) |
| @common_util.io_error_handle |
| def _write_all_relative_file_path_flags(hfile, rel_paths_dict, tag): |
| """Writes all relative file path flags' parameters. |
| |
| Args: |
| hfile: A file handler instance. |
| rel_paths_dict: A dict contains data of flag as a key and the relative |
| path string as its value. |
| tag: A string of tag, such as 'CMAKE_C_FLAGS'. |
| """ |
| for flag, path in rel_paths_dict.items(): |
| hfile.write( |
| _SET_RELATIVE_PATH.format(tag, _add_dollar_sign(tag), flag, |
| _build_cmake_path(path))) |
| |
| |
| @common_util.check_args(hfile=(TextIOWrapper, StringIO), flags=list, tag=str) |
| @common_util.io_error_handle |
| def _write_all_flags(hfile, flags, tag): |
| """Writes all flags to the project file. |
| |
| Args: |
| hfile: A file handler instance. |
| flags: A list of flag strings to be added. |
| tag: A string to be added a dollar sign. |
| """ |
| for flag in flags: |
| hfile.write(_SET_ALL_FLAGS.format(tag, _add_dollar_sign(tag), flag)) |
| |
| |
| def _add_dollar_sign(tag): |
| """Adds dollar sign to a string, e.g.: 'ANDROID_ROOT' -> '${ANDROID_ROOT}'. |
| |
| Args: |
| tag: A string to be added a dollar sign. |
| |
| Returns: |
| A dollar sign added string. |
| """ |
| return ''.join(['${', tag, '}']) |
| |
| |
| def _build_cmake_path(path, tag=''): |
| """Joins tag, '${ANDROID_ROOT}' and path into a new string. |
| |
| Args: |
| path: A string of a path. |
| tag: A string to be added in front of a dollar sign |
| |
| Returns: |
| The composed string. |
| """ |
| return ''.join([tag, _ANDROID_ROOT_SYMBOL, os.path.sep, path]) |
| |
| |
| @common_util.check_args(hfile=(TextIOWrapper, StringIO), is_system=bool) |
| @common_util.io_error_handle |
| def _write_all_includes(hfile, includes, is_system): |
| """Writes all included directories' paths to the CLion project file. |
| |
| Args: |
| hfile: A file handler instance. |
| includes: A list of included file paths. |
| is_system: A boolean of whether it's a system flag. |
| """ |
| if not includes: |
| return |
| system = '' |
| if is_system: |
| system = _SYSTEM |
| hfile.write(_INCLUDE_DIR.format(system)) |
| for include in includes: |
| hfile.write(_SET_INCLUDE_FORMAT.format(_build_cmake_path(include))) |
| hfile.write(_END_WITH_TWO_BLANK_LINES) |
| |
| |
| @common_util.check_args(hfile=(TextIOWrapper, StringIO)) |
| @common_util.io_error_handle |
| def _write_all_headers(hfile, includes): |
| """Writes all header directories' paths to the CLion project file. |
| |
| Args: |
| hfile: A file handler instance. |
| includes: A list of included file paths. |
| """ |
| if not includes: |
| return |
| hfile.write(_GLOB_RECURSE_TMP_HEADERS) |
| for include in includes: |
| hfile.write(_ALL_HEADER_FILES.format(_build_cmake_path(include))) |
| hfile.write(_END_WITH_ONE_BLANK_LINE) |
| hfile.write(_APPEND_SOURCE_FILES) |
| |
| |
| def _cleanup_executable_name(mod_name): |
| """Clean up an executable name to be suitable for CMake. |
| |
| Replace the last '@' of a module name with '-' and make it become a suitable |
| executable name for CMake. |
| |
| Args: |
| mod_name: A string of module name to be cleaned up. |
| |
| Returns: |
| A string of the executable name. |
| """ |
| return mod_name[::-1].replace('@', '-', 1)[::-1] |
