def __init__(self, context: CompileCtx, lib_root: str, extensions_dir: Optional[str], main_source_dirs: Set[str] = set(), main_programs: Set[str] = set(), no_property_checks: bool = False, generate_ada_api: bool = True, generate_gdb_hook: bool = True, pretty_print: bool = False, post_process_ada: PostProcessFn = None, post_process_cpp: PostProcessFn = None, post_process_python: PostProcessFn = None, post_process_ocaml: PostProcessFn = None, coverage: bool = False, relative_project: bool = False, unparse_script: Optional[str] = None): """ Generate sources for the analysis library. Also emit a tiny program useful for testing purposes. :param lib_root: Path of the directory in which the library should be generated. :param extensions_dir: Directory to contain extensions for code generation. If None is provided, assume there is no extension. :param main_source_dirs: List of source directories to use in the project file for mains. Source directories must be relative to the mains project file directory (i.e. $BUILD/src-mains). :param main_programs: List of names for programs to build in addition to the generated library. To each X program, there must be a X.adb source file in the $BUILD/src directory. :param no_property_checks: If True, do not emit safety checks in the generated code for properties. Namely, this disables null checks on field access. :param generate_ada_api: If True, generate the public Ada API. If False and there is no main to generate, do not generate this Ada API. :param generate_gdb_hook: Whether to generate the ".debug_gdb_scripts" section. Good for debugging, but better to disable for releases. :param pretty_print: If true, pretty-print the generated sources. :param post_process_ada: Optional post-processing for generated Ada source code. :param post_process_cpp: Optional post-processing for generated C++ source code. :param post_process_python: Optional post-processing for generated Python source code. :param post_process_ocaml: Optional post-processing for generated OCaml source code. :param coverage: Instrument the generated library to compute its code coverage. This requires GNATcoverage. :param relative_project: See libmanage's --relative-project option. """ self.context = context self.verbosity = context.verbosity self.lib_root = lib_root self.cache = Cache(os.path.join(self.lib_root, 'obj', 'langkit_cache')) self.extensions_dir = extensions_dir # TODO: contain the add_template_dir calls to this context (i.e. avoid # global mutation). if self.extensions_dir: add_template_dir(self.extensions_dir) for dirpath in keep(self.context.template_lookup_extra_dirs): add_template_dir(dirpath) self.no_property_checks = no_property_checks self.generate_ada_api = generate_ada_api or bool(main_programs) self.generate_gdb_hook = generate_gdb_hook self.generate_unparser = context.generate_unparser self.pretty_print = pretty_print self.post_process_ada = post_process_ada self.post_process_cpp = post_process_cpp self.post_process_python = post_process_python self.post_process_ocaml = post_process_ocaml self.coverage = coverage self.gnatcov = context.gnatcov self.relative_project = relative_project # Automatically add all source files in the "extensions/src" directory # to the generated library project. self.extensions_src_dir = None if self.extensions_dir: src_dir = path.join(self.extensions_dir, 'src') if path.isdir(src_dir): self.extensions_src_dir = src_dir for filename in os.listdir(src_dir): filepath = path.join(src_dir, filename) if path.isfile(filepath) and not filename.startswith('.'): self.context.additional_source_files.append(filepath) self.main_source_dirs = main_source_dirs self.main_programs = main_programs self.lib_name_low = context.ada_api_settings.lib_name.lower() """ Lower-case name for the generated library. """ self.lib_name_up = context.ada_api_settings.lib_name.upper() """ Upper-case name for the generated library. """ # Paths for the various directories in which code is generated self.src_dir = path.join(self.lib_root, "src") self.src_mains_dir = path.join(self.lib_root, "src-mains") self.scripts_dir = path.join(self.lib_root, "scripts") self.python_dir = path.join(self.lib_root, "python") self.python_pkg_dir = path.join( self.lib_root, "python", context.python_api_settings.module_name) self.ocaml_dir = path.join(self.lib_root, "ocaml") self.lib_project = path.join(self.lib_root, f"{self.lib_name_low}.gpr") self.mains_project = path.join(self.lib_root, "mains.gpr") self.dfa_code: DFACodeGenHolder """ Holder for the data structures used to generate code for the lexer state machine (DFA). As an optimization, it is left to None if we decide not to generate it (i.e. when the already generated sources are up-to-date). """ self._project_file_emitted = False """ Whether we emitted a project file for the generated library. :type: bool """ self.project_languages = {'Ada'} """ List of GPR names for languages used in the generated library. :type: set[str] """ self.library_interfaces = set() """ Set of source file base names for all sources that must appear in the "Interfaces" attribute of the generated library project file. :type: set[str] """ self.instr_md = InstrumentationMetadata() # Add all additional source files to the list of library interfaces and # declare them as such in instrumentation metadata. for f in context.additional_source_files: self.add_library_interface(f, generated=False) if self.coverage: assert self.gnatcov # Add the buffer-list unit from GNATcoverage's instrumentation to # the list of library interfaces. TODO: hopefully, we should not # have to do this anymore after S916-064 is addressed. self.library_interfaces.add(self.gnatcov.buffer_list_file(self)) self.main_project_file = os.path.join(self.lib_root, f'{self.lib_name_low}.gpr') self.unparse_script = unparse_script """ RA22-015: If set to something else than None, then the "dsl unparse" pass will be run on the given script. :type: langkit.compile_context.UnparseScript|None """ # Determine whether we have user external properties. If so, # automatically WITH $.Implementation.Extensions from the body of # $.Analysis and $.Implementation. if any(prop.user_external for prop in context.all_properties(include_inherited=True)): for unit in ('Analysis', 'Implementation', 'Implementation.C'): context.add_with_clause(unit, AdaSourceKind.body, '{}.Implementation.Extensions'.format( context.ada_api_settings.lib_name), use_clause=True)
def run(self, context: CompileCtx) -> None: for prop in context.all_properties(include_inherited=False): with prop.diagnostic_context: self.pass_fn(prop, context)