diff options
Diffstat (limited to 'tools/Vulkan-Tools/scripts/generate_source.py')
| -rwxr-xr-x | tools/Vulkan-Tools/scripts/generate_source.py | 279 |
1 files changed, 279 insertions, 0 deletions
diff --git a/tools/Vulkan-Tools/scripts/generate_source.py b/tools/Vulkan-Tools/scripts/generate_source.py new file mode 100755 index 00000000..59314533 --- /dev/null +++ b/tools/Vulkan-Tools/scripts/generate_source.py @@ -0,0 +1,279 @@ +#!/usr/bin/env python3 +# Copyright (c) 2019 The Khronos Group Inc. +# Copyright (c) 2019 Valve Corporation +# Copyright (c) 2019 LunarG, Inc. +# Copyright (c) 2019 Google Inc. +# Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# Copyright (c) 2023-2023 RasterGrid Kft. +# +# 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. +# +# Author: Mike Schuchardt <mikes@lunarg.com> + +import argparse +import filecmp +import os +import shutil +import sys +import re +import tempfile +import json +import common_codegen + +from xml.etree import ElementTree + +# Because we have special logic to import the Registry from input arguments and the BaseGenerator comes from the registry, we have to delay defining it until *after* +# the Registry has been imported. Yes this is awkward, but it was the least awkward way to make --verify work. +generators = {} + +def RunGenerators(api: str, registry: str, video_registry: str, directory: str, styleFile: str, targetFilter: str, flatOutput: bool): + + try: + common_codegen.RunShellCmd(f'clang-format --version') + has_clang_format = True + except: + has_clang_format = False + if not has_clang_format: + print("WARNING: Unable to find clang-format!") + + # These live in the Vulkan-Docs repo, but are pulled in via the + # Vulkan-Headers/registry folder + # At runtime we inject python path to find these helper scripts + scripts = os.path.dirname(registry) + scripts_directory_path = os.path.dirname(os.path.abspath(__file__)) + registry_headers_path = os.path.join(scripts_directory_path, scripts) + sys.path.insert(0, registry_headers_path) + try: + from reg import Registry + except: + print("ModuleNotFoundError: No module named 'reg'") # normal python error message + print(f'{registry_headers_path} is not pointing to the Vulkan-Headers registry directory.') + print("Inside Vulkan-Headers there is a registry/reg.py file that is used.") + sys.exit(1) # Return without call stack so easy to spot error + + from base_generator import BaseGeneratorOptions + from generators.mock_icd_generator import MockICDOutputGenerator + from generators.vulkan_tools_helper_file_generator import HelperFileOutputGenerator + from generators.vulkaninfo_generator import VulkanInfoGenerator + + # These set fields that are needed by both OutputGenerator and BaseGenerator, + # but are uniform and don't need to be set at a per-generated file level + from base_generator import (SetTargetApiName, SetMergedApiNames) + SetTargetApiName(api) + + # Generated directory and dispatch table helper file name may be API specific (e.g. Vulkan SC) + mock_icd_generated_directory = 'icd/generated' + vulkaninfo_generated_directory = 'vulkaninfo/generated' + + generators.update({ + 'vk_typemap_helper.h': { + 'generator' : HelperFileOutputGenerator, + 'genCombined': False, + 'directory' : mock_icd_generated_directory, + }, + 'function_declarations.h': { + 'generator' : MockICDOutputGenerator, + 'genCombined': False, + 'directory' : mock_icd_generated_directory, + }, + 'function_definitions.h': { + 'generator' : MockICDOutputGenerator, + 'genCombined': False, + 'directory' : mock_icd_generated_directory, + }, + 'vulkaninfo.hpp': { + 'generator' : VulkanInfoGenerator, + 'genCombined': False, + 'directory' : vulkaninfo_generated_directory, + }, + }) + + unknownTargets = [x for x in (targetFilter if targetFilter else []) if x not in generators.keys()] + if unknownTargets: + print(f'ERROR: No generator options for unknown target(s): {", ".join(unknownTargets)}', file=sys.stderr) + return 1 + + # Filter if --target is passed in + targets = [x for x in generators.keys() if not targetFilter or x in targetFilter] + + for index, target in enumerate(targets, start=1): + print(f'[{index}|{len(targets)}] Generating {target}') + + # First grab a class constructor object and create an instance + generator = generators[target]['generator'] + gen = generator() + + # This code and the 'genCombined' generator metadata is used by downstream + # users to generate code with all Vulkan APIs merged into the target API variant + # (e.g. Vulkan SC) when needed. The constructed apiList is also used to filter + # out non-applicable extensions later below. + apiList = [api] + if api != 'vulkan' and generators[target]['genCombined']: + SetMergedApiNames('vulkan') + apiList.append('vulkan') + else: + SetMergedApiNames(None) + + # For people who want to generate all the files in a single director + if flatOutput: + outDirectory = os.path.abspath(os.path.join(directory)) + else: + outDirectory = os.path.abspath(os.path.join(directory, generators[target]['directory'])) + + options = BaseGeneratorOptions( + customFileName = target, + customDirectory = outDirectory) + + if not os.path.exists(outDirectory): + os.makedirs(outDirectory) + + # Create the registry object with the specified generator and generator + # options. The options are set before XML loading as they may affect it. + reg = Registry(gen, options) + + # Parse the specified registry XML into an ElementTree object + tree = ElementTree.parse(registry) + + # Load the XML tree into the registry object + reg.loadElementTree(tree) + + # Set the path to the video registry so that videoStd is available + reg.genOpts.videoXmlPath = video_registry + + # Finally, use the output generator to create the requested target + reg.apiGen() + + # Run clang-format on the file + if has_clang_format and styleFile: + common_codegen.RunShellCmd(f'clang-format -i --style=file:{styleFile} {os.path.join(outDirectory, target)}') + + +def main(argv): + + # files to exclude from --verify check + verify_exclude = ['.clang-format'] # None currently + + parser = argparse.ArgumentParser(description='Generate source code for this repository') + parser.add_argument('registry', metavar='REGISTRY_PATH', help='path to the Vulkan-Headers registry directory') + parser.add_argument('--api', + default='vulkan', + choices=['vulkan', 'vulkansc'], + help='Specify API name to generate') + parser.add_argument('--generated-version', help='sets the header version used to generate the repo') + group = parser.add_mutually_exclusive_group() + group.add_argument('--target', nargs='+', help='only generate file names passed in') + group.add_argument('-i', '--incremental', action='store_true', help='only update repo files that change') + group.add_argument('-v', '--verify', action='store_true', help='verify repo files match generator output') + group.add_argument('-o', action='store', dest='directory', help='Create target and related files in specified directory') + args = parser.parse_args(argv) + + repo_dir = common_codegen.RepoRelative('.') + + registry = os.path.abspath(os.path.join(args.registry, 'vk.xml')) + video_registry = os.path.abspath(os.path.join(args.registry, 'video.xml')) + if not os.path.isfile(registry) and not os.path.isfile(registry): + registry = os.path.abspath(os.path.join(args.registry, 'Vulkan-Headers/registry/vk.xml')) + if not os.path.isfile(registry): + print(f'cannot find vk.xml in {args.registry}') + return -1 + video_registry = os.path.abspath(os.path.join(args.registry, 'Vulkan-Headers/registry/video.xml')) + if not os.path.isfile(video_registry): + print(f'{video_registry} does not exist') + return -1 + + # Need pass style file incase running with --verify and it can't find the file automatically in the temp directory + style_file = os.path.join(repo_dir, '.clang-format') + + # get directory where generators will run + if args.verify or args.incremental: + # generate in temp directory so we can compare or copy later + temp_obj = tempfile.TemporaryDirectory(prefix='vulkan_tools_codegen_') + temp_dir = temp_obj.name + gen_dir = temp_dir + elif args.directory: + gen_dir = args.directory + else: + # generate directly in the repo + gen_dir = repo_dir + + RunGenerators(api=args.api,registry=registry, video_registry=video_registry, directory=gen_dir, styleFile=style_file, targetFilter=args.target, flatOutput=False) + + # optional post-generation steps + if args.verify: + # compare contents of temp dir and repo + temp_files = {} + repo_files = {} + for details in generators.values(): + if details['directory'] not in temp_files: + temp_files[details['directory']] = set() + temp_files[details['directory']].update(set(os.listdir(os.path.join(temp_dir, details['directory'])))) + if details['directory'] not in repo_files: + repo_files[details['directory']] = set() + repo_files[details['directory']].update(set(os.listdir(os.path.join(repo_dir, details['directory']))) - set(verify_exclude)) + + # compare contents of temp dir and repo + files_match = True + for filename, details in generators.items(): + if filename not in repo_files[details['directory']]: + print('ERROR: Missing repo file', filename) + files_match = False + elif filename not in temp_files[details['directory']]: + print('ERROR: Missing generator for', filename) + files_match = False + elif not filecmp.cmp(os.path.join(temp_dir, details['directory'], filename), + os.path.join(repo_dir, details['directory'], filename), + shallow=False): + print('ERROR: Repo files do not match generator output for', filename) + files_match = False + + # return code for test scripts + if files_match: + print('SUCCESS: Repo files match generator output') + return 0 + return 1 + + elif args.incremental: + # copy missing or differing files from temp directory to repo + for filename, details in generators.items(): + temp_filename = os.path.join(temp_dir, details['directory'], filename) + repo_filename = os.path.join(repo_dir, details['directory'], filename) + if not os.path.exists(repo_filename) or \ + not filecmp.cmp(temp_filename, repo_filename, shallow=False): + print('update', repo_filename) + shutil.copyfile(temp_filename, repo_filename) + + # write out the header version used to generate the code to a checked in CMake file + if args.generated_version: + json_files = [] + json_files.append(common_codegen.RepoRelative('icd/VkICD_mock_icd.json.in')) + for json_file in json_files: + with open(json_file) as f: + data = json.load(f) + + data["ICD"]["api_version"] = args.generated_version + + with open(json_file, mode='w', encoding='utf-8', newline='\n') as f: + f.write(json.dumps(data, indent=4)) + + # Update the CMake project version + with open(common_codegen.RepoRelative('CMakeLists.txt'), "r+") as f: + data = f.read() + f.seek(0) + f.write(re.sub("project.*VERSION.*", f"project(Vulkan-Tools VERSION {args.generated_version})", data)) + f.truncate() + + return 0 + +if __name__ == '__main__': + sys.exit(main(sys.argv[1:])) + |