frida 16.2.1 → 16.2.2

package/releng/meson/mesonbuild/cmake/data/preload.cmake

@@ -0,0 +1,82 @@
+if(MESON_PS_LOADED)
+  return()
+endif()
+
+set(MESON_PS_LOADED ON)
+
+cmake_policy(PUSH)
+cmake_policy(SET CMP0054 NEW) # https://cmake.org/cmake/help/latest/policy/CMP0054.html
+
+# Dummy macros that have a special meaning in the meson code
+macro(meson_ps_execute_delayed_calls)
+endmacro()
+
+macro(meson_ps_reload_vars)
+endmacro()
+
+macro(meson_ps_disabled_function)
+  message(WARNING "The function '${ARGV0}' is disabled in the context of CMake subprojects.\n"
+                  "This should not be an issue but may lead to compilation errors.")
+endmacro()
+
+# Helper macro to inspect the current CMake state
+macro(meson_ps_inspect_vars)
+  set(MESON_PS_CMAKE_CURRENT_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}")
+  set(MESON_PS_CMAKE_CURRENT_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
+  meson_ps_execute_delayed_calls()
+endmacro()
+
+
+# Override some system functions with custom code and forward the args
+# to the original function
+macro(add_custom_command)
+  meson_ps_inspect_vars()
+  _add_custom_command(${ARGV})
+endmacro()
+
+macro(add_custom_target)
+  meson_ps_inspect_vars()
+  _add_custom_target(${ARGV})
+endmacro()
+
+macro(set_property)
+  meson_ps_inspect_vars()
+  _set_property(${ARGV})
+endmacro()
+
+function(set_source_files_properties)
+  set(FILES)
+  set(I 0)
+  set(PROPERTIES OFF)
+
+  while(I LESS ARGC)
+    if(NOT PROPERTIES)
+      if("${ARGV${I}}" STREQUAL "PROPERTIES")
+        set(PROPERTIES ON)
+      else()
+        list(APPEND FILES "${ARGV${I}}")
+      endif()
+
+      math(EXPR I "${I} + 1")
+    else()
+      set(ID_IDX ${I})
+      math(EXPR PROP_IDX "${ID_IDX} + 1")
+
+      set(ID   "${ARGV${ID_IDX}}")
+      set(PROP "${ARGV${PROP_IDX}}")
+
+      set_property(SOURCE ${FILES} PROPERTY "${ID}" "${PROP}")
+      math(EXPR I "${I} + 2")
+    endif()
+  endwhile()
+endfunction()
+
+# Disable some functions that would mess up the CMake meson integration
+macro(target_precompile_headers)
+  meson_ps_disabled_function(target_precompile_headers)
+endmacro()
+
+set(MESON_PS_DELAYED_CALLS add_custom_command;add_custom_target;set_property)
+meson_ps_reload_vars()
+
+cmake_policy(POP)

package/releng/meson/mesonbuild/cmake/executor.py

@@ -0,0 +1,241 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2019 The Meson development team
+
+from __future__ import annotations
+
+import subprocess as S
+from threading import Thread
+import typing as T
+import re
+import os
+
+from .. import mlog
+from ..mesonlib import PerMachine, Popen_safe, version_compare, is_windows, OptionKey
+from ..programs import find_external_program, NonExistingExternalProgram
+
+if T.TYPE_CHECKING:
+    from pathlib import Path
+
+    from ..environment import Environment
+    from ..mesonlib import MachineChoice
+    from ..programs import ExternalProgram
+
+    TYPE_result = T.Tuple[int, T.Optional[str], T.Optional[str]]
+    TYPE_cache_key = T.Tuple[str, T.Tuple[str, ...], str, T.FrozenSet[T.Tuple[str, str]]]
+
+class CMakeExecutor:
+    # The class's copy of the CMake path. Avoids having to search for it
+    # multiple times in the same Meson invocation.
+    class_cmakebin: PerMachine[T.Optional[ExternalProgram]] = PerMachine(None, None)
+    class_cmakevers: PerMachine[T.Optional[str]] = PerMachine(None, None)
+    class_cmake_cache: T.Dict[T.Any, TYPE_result] = {}
+
+    def __init__(self, environment: 'Environment', version: str, for_machine: MachineChoice, silent: bool = False):
+        self.min_version = version
+        self.environment = environment
+        self.for_machine = for_machine
+        self.cmakebin, self.cmakevers = self.find_cmake_binary(self.environment, silent=silent)
+        self.always_capture_stderr = True
+        self.print_cmout = False
+        self.prefix_paths: T.List[str] = []
+        self.extra_cmake_args: T.List[str] = []
+
+        if self.cmakebin is None:
+            return
+
+        if not version_compare(self.cmakevers, self.min_version):
+            mlog.warning(
+                'The version of CMake', mlog.bold(self.cmakebin.get_path()),
+                'is', mlog.bold(self.cmakevers), 'but version', mlog.bold(self.min_version),
+                'is required')
+            self.cmakebin = None
+            return
+
+        self.prefix_paths = self.environment.coredata.options[OptionKey('cmake_prefix_path', machine=self.for_machine)].value
+        if self.prefix_paths:
+            self.extra_cmake_args += ['-DCMAKE_PREFIX_PATH={}'.format(';'.join(self.prefix_paths))]
+
+    def find_cmake_binary(self, environment: 'Environment', silent: bool = False) -> T.Tuple[T.Optional['ExternalProgram'], T.Optional[str]]:
+        # Only search for CMake the first time and store the result in the class
+        # definition
+        if isinstance(CMakeExecutor.class_cmakebin[self.for_machine], NonExistingExternalProgram):
+            mlog.debug(f'CMake binary for {self.for_machine} is cached as not found')
+            return None, None
+        elif CMakeExecutor.class_cmakebin[self.for_machine] is not None:
+            mlog.debug(f'CMake binary for {self.for_machine} is cached.')
+        else:
+            assert CMakeExecutor.class_cmakebin[self.for_machine] is None
+
+            mlog.debug(f'CMake binary for {self.for_machine} is not cached')
+            for potential_cmakebin in find_external_program(
+                    environment, self.for_machine, 'cmake', 'CMake',
+                    environment.default_cmake, allow_default_for_cross=False):
+                version_if_ok = self.check_cmake(potential_cmakebin)
+                if not version_if_ok:
+                    continue
+                if not silent:
+                    mlog.log('Found CMake:', mlog.bold(potential_cmakebin.get_path()),
+                             f'({version_if_ok})')
+                CMakeExecutor.class_cmakebin[self.for_machine] = potential_cmakebin
+                CMakeExecutor.class_cmakevers[self.for_machine] = version_if_ok
+                break
+            else:
+                if not silent:
+                    mlog.log('Found CMake:', mlog.red('NO'))
+                # Set to False instead of None to signify that we've already
+                # searched for it and not found it
+                CMakeExecutor.class_cmakebin[self.for_machine] = NonExistingExternalProgram()
+                CMakeExecutor.class_cmakevers[self.for_machine] = None
+                return None, None
+
+        return CMakeExecutor.class_cmakebin[self.for_machine], CMakeExecutor.class_cmakevers[self.for_machine]
+
+    def check_cmake(self, cmakebin: 'ExternalProgram') -> T.Optional[str]:
+        if not cmakebin.found():
+            mlog.log(f'Did not find CMake {cmakebin.name!r}')
+            return None
+        try:
+            cmd = cmakebin.get_command()
+            p, out = Popen_safe(cmd + ['--version'])[0:2]
+            if p.returncode != 0:
+                mlog.warning('Found CMake {!r} but couldn\'t run it'
+                             ''.format(' '.join(cmd)))
+                return None
+        except FileNotFoundError:
+            mlog.warning('We thought we found CMake {!r} but now it\'s not there. How odd!'
+                         ''.format(' '.join(cmd)))
+            return None
+        except PermissionError:
+            msg = 'Found CMake {!r} but didn\'t have permissions to run it.'.format(' '.join(cmd))
+            if not is_windows():
+                msg += '\n\nOn Unix-like systems this is often caused by scripts that are not executable.'
+            mlog.warning(msg)
+            return None
+
+        cmvers = re.search(r'(cmake|cmake3)\s*version\s*([\d.]+)', out)
+        if cmvers is not None:
+            return cmvers.group(2)
+        mlog.warning(f'We thought we found CMake {cmd!r}, but it was missing the expected '
+                     'version string in its output.')
+        return None
+
+    def set_exec_mode(self, print_cmout: T.Optional[bool] = None, always_capture_stderr: T.Optional[bool] = None) -> None:
+        if print_cmout is not None:
+            self.print_cmout = print_cmout
+        if always_capture_stderr is not None:
+            self.always_capture_stderr = always_capture_stderr
+
+    def _cache_key(self, args: T.List[str], build_dir: Path, env: T.Optional[T.Dict[str, str]]) -> TYPE_cache_key:
+        fenv = frozenset(env.items()) if env is not None else frozenset()
+        targs = tuple(args)
+        return (self.cmakebin.get_path(), targs, build_dir.as_posix(), fenv)
+
+    def _call_cmout_stderr(self, args: T.List[str], build_dir: Path, env: T.Optional[T.Dict[str, str]]) -> TYPE_result:
+        cmd = self.cmakebin.get_command() + args
+        proc = S.Popen(cmd, stdout=S.PIPE, stderr=S.PIPE, cwd=str(build_dir), env=env)  # TODO [PYTHON_37]: drop Path conversion
+
+        # stdout and stderr MUST be read at the same time to avoid pipe
+        # blocking issues. The easiest way to do this is with a separate
+        # thread for one of the pipes.
+        def print_stdout() -> None:
+            while True:
+                line = proc.stdout.readline()
+                if not line:
+                    break
+                mlog.log(line.decode(errors='ignore').strip('\n'))
+            proc.stdout.close()
+
+        t = Thread(target=print_stdout)
+        t.start()
+
+        try:
+            # Read stderr line by line and log non trace lines
+            raw_trace = ''
+            tline_start_reg = re.compile(r'^\s*(.*\.(cmake|txt))\(([0-9]+)\):\s*(\w+)\(.*$')
+            inside_multiline_trace = False
+            while True:
+                line_raw = proc.stderr.readline()
+                if not line_raw:
+                    break
+                line = line_raw.decode(errors='ignore')
+                if tline_start_reg.match(line):
+                    raw_trace += line
+                    inside_multiline_trace = not line.endswith(' )\n')
+                elif inside_multiline_trace:
+                    raw_trace += line
+                else:
+                    mlog.warning(line.strip('\n'))
+
+        finally:
+            proc.stderr.close()
+            t.join()
+            proc.wait()
+
+        return proc.returncode, None, raw_trace
+
+    def _call_cmout(self, args: T.List[str], build_dir: Path, env: T.Optional[T.Dict[str, str]]) -> TYPE_result:
+        cmd = self.cmakebin.get_command() + args
+        proc = S.Popen(cmd, stdout=S.PIPE, stderr=S.STDOUT, cwd=str(build_dir), env=env)  # TODO [PYTHON_37]: drop Path conversion
+        while True:
+            line = proc.stdout.readline()
+            if not line:
+                break
+            mlog.log(line.decode(errors='ignore').strip('\n'))
+        proc.stdout.close()
+        proc.wait()
+        return proc.returncode, None, None
+
+    def _call_quiet(self, args: T.List[str], build_dir: Path, env: T.Optional[T.Dict[str, str]]) -> TYPE_result:
+        build_dir.mkdir(parents=True, exist_ok=True)
+        cmd = self.cmakebin.get_command() + args
+        ret = S.run(cmd, env=env, cwd=str(build_dir), close_fds=False,
+                    stdout=S.PIPE, stderr=S.PIPE, universal_newlines=False)   # TODO [PYTHON_37]: drop Path conversion
+        rc = ret.returncode
+        out = ret.stdout.decode(errors='ignore')
+        err = ret.stderr.decode(errors='ignore')
+        return rc, out, err
+
+    def _call_impl(self, args: T.List[str], build_dir: Path, env: T.Optional[T.Dict[str, str]]) -> TYPE_result:
+        mlog.debug(f'Calling CMake ({self.cmakebin.get_command()}) in {build_dir} with:')
+        for i in args:
+            mlog.debug(f'  - "{i}"')
+        if not self.print_cmout:
+            return self._call_quiet(args, build_dir, env)
+        else:
+            if self.always_capture_stderr:
+                return self._call_cmout_stderr(args, build_dir, env)
+            else:
+                return self._call_cmout(args, build_dir, env)
+
+    def call(self, args: T.List[str], build_dir: Path, env: T.Optional[T.Dict[str, str]] = None, disable_cache: bool = False) -> TYPE_result:
+        if env is None:
+            env = os.environ.copy()
+
+        args = args + self.extra_cmake_args
+        if disable_cache:
+            return self._call_impl(args, build_dir, env)
+
+        # First check if cached, if not call the real cmake function
+        cache = CMakeExecutor.class_cmake_cache
+        key = self._cache_key(args, build_dir, env)
+        if key not in cache:
+            cache[key] = self._call_impl(args, build_dir, env)
+        return cache[key]
+
+    def found(self) -> bool:
+        return self.cmakebin is not None
+
+    def version(self) -> str:
+        return self.cmakevers
+
+    def executable_path(self) -> str:
+        return self.cmakebin.get_path()
+
+    def get_command(self) -> T.List[str]:
+        return self.cmakebin.get_command()
+
+    def get_cmake_prefix_paths(self) -> T.List[str]:
+        return self.prefix_paths
+
+    def machine_choice(self) -> MachineChoice:
+        return self.for_machine

package/releng/meson/mesonbuild/cmake/fileapi.py

@@ -0,0 +1,324 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2019 The Meson development team
+
+from __future__ import annotations
+
+from .common import CMakeException, CMakeBuildFile, CMakeConfiguration
+import typing as T
+from .. import mlog
+from pathlib import Path
+import json
+import re
+
+STRIP_KEYS = ['cmake', 'reply', 'backtrace', 'backtraceGraph', 'version']
+
+class CMakeFileAPI:
+    def __init__(self, build_dir: Path):
+        self.build_dir = build_dir
+        self.api_base_dir = self.build_dir / '.cmake' / 'api' / 'v1'
+        self.request_dir = self.api_base_dir / 'query' / 'client-meson'
+        self.reply_dir = self.api_base_dir / 'reply'
+        self.cmake_sources: T.List[CMakeBuildFile] = []
+        self.cmake_configurations: T.List[CMakeConfiguration] = []
+        self.project_version = ''
+        self.kind_resolver_map = {
+            'codemodel': self._parse_codemodel,
+            'cache': self._parse_cache,
+            'cmakeFiles': self._parse_cmakeFiles,
+        }
+
+    def get_cmake_sources(self) -> T.List[CMakeBuildFile]:
+        return self.cmake_sources
+
+    def get_cmake_configurations(self) -> T.List[CMakeConfiguration]:
+        return self.cmake_configurations
+
+    def get_project_version(self) -> str:
+        return self.project_version
+
+    def setup_request(self) -> None:
+        self.request_dir.mkdir(parents=True, exist_ok=True)
+
+        query = {
+            'requests': [
+                {'kind': 'codemodel', 'version': {'major': 2, 'minor': 0}},
+                {'kind': 'cache', 'version': {'major': 2, 'minor': 0}},
+                {'kind': 'cmakeFiles', 'version': {'major': 1, 'minor': 0}},
+            ]
+        }
+
+        query_file = self.request_dir / 'query.json'
+        query_file.write_text(json.dumps(query, indent=2), encoding='utf-8')
+
+    def load_reply(self) -> None:
+        if not self.reply_dir.is_dir():
+            raise CMakeException('No response from the CMake file API')
+
+        root = None
+        reg_index = re.compile(r'^index-.*\.json$')
+        for i in self.reply_dir.iterdir():
+            if reg_index.match(i.name):
+                root = i
+                break
+
+        if not root:
+            raise CMakeException('Failed to find the CMake file API index')
+
+        index = self._reply_file_content(root)   # Load the root index
+        index = self._strip_data(index)          # Avoid loading duplicate files
+        index = self._resolve_references(index)  # Load everything
+        index = self._strip_data(index)          # Strip unused data (again for loaded files)
+
+        # Debug output
+        debug_json = self.build_dir / '..' / 'fileAPI.json'
+        debug_json = debug_json.resolve()
+        debug_json.write_text(json.dumps(index, indent=2), encoding='utf-8')
+        mlog.cmd_ci_include(debug_json.as_posix())
+
+        # parse the JSON
+        for i in index['objects']:
+            assert isinstance(i, dict)
+            assert 'kind' in i
+            assert i['kind'] in self.kind_resolver_map
+
+            self.kind_resolver_map[i['kind']](i)
+
+    def _parse_codemodel(self, data: T.Dict[str, T.Any]) -> None:
+        assert 'configurations' in data
+        assert 'paths' in data
+
+        source_dir = data['paths']['source']
+        build_dir = data['paths']['build']
+
+        # The file API output differs quite a bit from the server
+        # output. It is more flat than the server output and makes
+        # heavy use of references. Here these references are
+        # resolved and the resulting data structure is identical
+        # to the CMake serve output.
+
+        def helper_parse_dir(dir_entry: T.Dict[str, T.Any]) -> T.Tuple[Path, Path]:
+            src_dir = Path(dir_entry.get('source', '.'))
+            bld_dir = Path(dir_entry.get('build', '.'))
+            src_dir = src_dir if src_dir.is_absolute() else source_dir / src_dir
+            bld_dir = bld_dir if bld_dir.is_absolute() else build_dir / bld_dir
+            src_dir = src_dir.resolve()
+            bld_dir = bld_dir.resolve()
+
+            return src_dir, bld_dir
+
+        def parse_sources(comp_group: T.Dict[str, T.Any], tgt: T.Dict[str, T.Any]) -> T.Tuple[T.List[Path], T.List[Path], T.List[int]]:
+            gen = []
+            src = []
+            idx = []
+
+            src_list_raw = tgt.get('sources', [])
+            for i in comp_group.get('sourceIndexes', []):
+                if i >= len(src_list_raw) or 'path' not in src_list_raw[i]:
+                    continue
+                if src_list_raw[i].get('isGenerated', False):
+                    gen += [Path(src_list_raw[i]['path'])]
+                else:
+                    src += [Path(src_list_raw[i]['path'])]
+                idx += [i]
+
+            return src, gen, idx
+
+        def parse_target(tgt: T.Dict[str, T.Any]) -> T.Dict[str, T.Any]:
+            src_dir, bld_dir = helper_parse_dir(cnf.get('paths', {}))
+
+            # Parse install paths (if present)
+            install_paths = []
+            if 'install' in tgt:
+                prefix = Path(tgt['install']['prefix']['path'])
+                install_paths = [prefix / x['path'] for x in tgt['install']['destinations']]
+                install_paths = list(set(install_paths))
+
+            # On the first look, it looks really nice that the CMake devs have
+            # decided to use arrays for the linker flags. However, this feeling
+            # soon turns into despair when you realize that there only one entry
+            # per type in most cases, and we still have to do manual string splitting.
+            link_flags = []
+            link_libs = []
+            for i in tgt.get('link', {}).get('commandFragments', []):
+                if i['role'] == 'flags':
+                    link_flags += [i['fragment']]
+                elif i['role'] == 'libraries':
+                    link_libs += [i['fragment']]
+                elif i['role'] == 'libraryPath':
+                    link_flags += ['-L{}'.format(i['fragment'])]
+                elif i['role'] == 'frameworkPath':
+                    link_flags += ['-F{}'.format(i['fragment'])]
+            for i in tgt.get('archive', {}).get('commandFragments', []):
+                if i['role'] == 'flags':
+                    link_flags += [i['fragment']]
+
+            # TODO The `dependencies` entry is new in the file API.
+            #      maybe we can make use of that in addition to the
+            #      implicit dependency detection
+            tgt_data = {
+                'artifacts': [Path(x.get('path', '')) for x in tgt.get('artifacts', [])],
+                'sourceDirectory': src_dir,
+                'buildDirectory': bld_dir,
+                'name': tgt.get('name', ''),
+                'fullName': tgt.get('nameOnDisk', ''),
+                'hasInstallRule': 'install' in tgt,
+                'installPaths': install_paths,
+                'linkerLanguage': tgt.get('link', {}).get('language', 'CXX'),
+                'linkLibraries': ' '.join(link_libs),  # See previous comment block why we join the array
+                'linkFlags': ' '.join(link_flags),     # See previous comment block why we join the array
+                'type': tgt.get('type', 'EXECUTABLE'),
+                'fileGroups': [],
+            }
+
+            processed_src_idx = []
+            for cg in tgt.get('compileGroups', []):
+                # Again, why an array, when there is usually only one element
+                # and arguments are separated with spaces...
+                flags = []
+                for i in cg.get('compileCommandFragments', []):
+                    flags += [i['fragment']]
+
+                cg_data = {
+                    'defines': [x.get('define', '') for x in cg.get('defines', [])],
+                    'compileFlags': ' '.join(flags),
+                    'language': cg.get('language', 'C'),
+                    'isGenerated': None,  # Set later, flag is stored per source file
+                    'sources': [],
+                    'includePath': cg.get('includes', []),
+                }
+
+                normal_src, generated_src, src_idx = parse_sources(cg, tgt)
+                if normal_src:
+                    cg_data = dict(cg_data)
+                    cg_data['isGenerated'] = False
+                    cg_data['sources'] = normal_src
+                    tgt_data['fileGroups'] += [cg_data]
+                if generated_src:
+                    cg_data = dict(cg_data)
+                    cg_data['isGenerated'] = True
+                    cg_data['sources'] = generated_src
+                    tgt_data['fileGroups'] += [cg_data]
+                processed_src_idx += src_idx
+
+            # Object libraries have no compile groups, only source groups.
+            # So we add all the source files to a dummy source group that were
+            # not found in the previous loop
+            normal_src = []
+            generated_src = []
+            for idx, src in enumerate(tgt.get('sources', [])):
+                if idx in processed_src_idx:
+                    continue
+
+                if src.get('isGenerated', False):
+                    generated_src += [src['path']]
+                else:
+                    normal_src += [src['path']]
+
+            if normal_src:
+                tgt_data['fileGroups'] += [{
+                    'isGenerated': False,
+                    'sources': normal_src,
+                }]
+            if generated_src:
+                tgt_data['fileGroups'] += [{
+                    'isGenerated': True,
+                    'sources': generated_src,
+                }]
+            return tgt_data
+
+        def parse_project(pro: T.Dict[str, T.Any]) -> T.Dict[str, T.Any]:
+            # Only look at the first directory specified in directoryIndexes
+            # TODO Figure out what the other indexes are there for
+            p_src_dir = source_dir
+            p_bld_dir = build_dir
+            try:
+                p_src_dir, p_bld_dir = helper_parse_dir(cnf['directories'][pro['directoryIndexes'][0]])
+            except (IndexError, KeyError):
+                pass
+
+            pro_data = {
+                'name': pro.get('name', ''),
+                'sourceDirectory': p_src_dir,
+                'buildDirectory': p_bld_dir,
+                'targets': [],
+            }
+
+            for ref in pro.get('targetIndexes', []):
+                tgt = {}
+                try:
+                    tgt = cnf['targets'][ref]
+                except (IndexError, KeyError):
+                    pass
+                pro_data['targets'] += [parse_target(tgt)]
+
+            return pro_data
+
+        for cnf in data.get('configurations', []):
+            cnf_data = {
+                'name': cnf.get('name', ''),
+                'projects': [],
+            }
+
+            for pro in cnf.get('projects', []):
+                cnf_data['projects'] += [parse_project(pro)]
+
+            self.cmake_configurations += [CMakeConfiguration(cnf_data)]
+
+    def _parse_cmakeFiles(self, data: T.Dict[str, T.Any]) -> None:
+        assert 'inputs' in data
+        assert 'paths' in data
+
+        src_dir = Path(data['paths']['source'])
+
+        for i in data['inputs']:
+            path = Path(i['path'])
+            path = path if path.is_absolute() else src_dir / path
+            self.cmake_sources += [CMakeBuildFile(path, i.get('isCMake', False), i.get('isGenerated', False))]
+
+    def _parse_cache(self, data: T.Dict[str, T.Any]) -> None:
+        assert 'entries' in data
+
+        for e in data['entries']:
+            if e['name'] == 'CMAKE_PROJECT_VERSION':
+                self.project_version = e['value']
+
+    def _strip_data(self, data: T.Any) -> T.Any:
+        if isinstance(data, list):
+            for idx, i in enumerate(data):
+                data[idx] = self._strip_data(i)
+
+        elif isinstance(data, dict):
+            new = {}
+            for key, val in data.items():
+                if key not in STRIP_KEYS:
+                    new[key] = self._strip_data(val)
+            data = new
+
+        return data
+
+    def _resolve_references(self, data: T.Any) -> T.Any:
+        if isinstance(data, list):
+            for idx, i in enumerate(data):
+                data[idx] = self._resolve_references(i)
+
+        elif isinstance(data, dict):
+            # Check for the "magic" reference entry and insert
+            # it into the root data dict
+            if 'jsonFile' in data:
+                data.update(self._reply_file_content(data['jsonFile']))
+
+            for key, val in data.items():
+                data[key] = self._resolve_references(val)
+
+        return data
+
+    def _reply_file_content(self, filename: Path) -> T.Dict[str, T.Any]:
+        real_path = self.reply_dir / filename
+        if not real_path.exists():
+            raise CMakeException(f'File "{real_path}" does not exist')
+
+        data = json.loads(real_path.read_text(encoding='utf-8'))
+        assert isinstance(data, dict)
+        for i in data.keys():
+            assert isinstance(i, str)
+        return data