#!/usr/bin/python3 -i # # Copyright (c) 2015-2017 The Khronos Group Inc. # Copyright (c) 2015-2017 Valve Corporation # Copyright (c) 2015-2017 LunarG, Inc. # Copyright (c) 2015-2017 Google Inc. # # 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: Mark Lobodzinski # Author: Tobin Ehlis # Author: John Zulauf import os,re,sys import xml.etree.ElementTree as etree from generator import * from collections import namedtuple from common_codegen import * # # HelperFileOutputGeneratorOptions - subclass of GeneratorOptions. class HelperFileOutputGeneratorOptions(GeneratorOptions): def __init__(self, conventions = None, filename = None, directory = '.', apiname = None, profile = None, versions = '.*', emitversions = '.*', defaultExtensions = None, addExtensions = None, removeExtensions = None, emitExtensions = None, sortProcedure = regSortFeatures, prefixText = "", genFuncPointers = True, protectFile = True, protectFeature = True, apicall = '', apientry = '', apientryp = '', alignFuncParam = 0, library_name = '', expandEnumerants = True, helper_file_type = ''): GeneratorOptions.__init__(self, conventions, filename, directory, apiname, profile, versions, emitversions, defaultExtensions, addExtensions, removeExtensions, emitExtensions, sortProcedure) self.prefixText = prefixText self.genFuncPointers = genFuncPointers self.protectFile = protectFile self.protectFeature = protectFeature self.apicall = apicall self.apientry = apientry self.apientryp = apientryp self.alignFuncParam = alignFuncParam self.library_name = library_name self.helper_file_type = helper_file_type # # HelperFileOutputGenerator - subclass of OutputGenerator. Outputs Vulkan helper files class HelperFileOutputGenerator(OutputGenerator): """Generate helper file based on XML element attributes""" def __init__(self, errFile = sys.stderr, warnFile = sys.stderr, diagFile = sys.stdout): OutputGenerator.__init__(self, errFile, warnFile, diagFile) # Internal state - accumulators for different inner block text self.enum_output = '' # string built up of enum string routines # Internal state - accumulators for different inner block text self.structNames = [] # List of Vulkan struct typenames self.structTypes = dict() # Map of Vulkan struct typename to required VkStructureType self.structMembers = [] # List of StructMemberData records for all Vulkan structs self.object_types = [] # List of all handle types self.object_type_aliases = [] # Aliases to handles types (for handles that were extensions) self.debug_report_object_types = [] # Handy copy of debug_report_object_type enum data self.core_object_types = [] # Handy copy of core_object_type enum data self.device_extension_info = dict() # Dict of device extension name defines and ifdef values self.instance_extension_info = dict() # Dict of instance extension name defines and ifdef values # Named tuples to store struct and command data self.StructType = namedtuple('StructType', ['name', 'value']) self.CommandParam = namedtuple('CommandParam', ['type', 'name', 'ispointer', 'isstaticarray', 'isconst', 'iscount', 'len', 'extstructs', 'cdecl']) self.StructMemberData = namedtuple('StructMemberData', ['name', 'members', 'ifdef_protect']) self.custom_construct_params = { # safe_VkGraphicsPipelineCreateInfo needs to know if subpass has color and\or depth\stencil attachments to use its pointers 'VkGraphicsPipelineCreateInfo' : ', const bool uses_color_attachment, const bool uses_depthstencil_attachment', # safe_VkPipelineViewportStateCreateInfo needs to know if viewport and scissor is dynamic to use its pointers 'VkPipelineViewportStateCreateInfo' : ', const bool is_dynamic_viewports, const bool is_dynamic_scissors', } # # Called once at the beginning of each run def beginFile(self, genOpts): OutputGenerator.beginFile(self, genOpts) # User-supplied prefix text, if any (list of strings) self.helper_file_type = genOpts.helper_file_type self.library_name = genOpts.library_name # File Comment file_comment = '// *** THIS FILE IS GENERATED - DO NOT EDIT ***\n' file_comment += '// See helper_file_generator.py for modifications\n' write(file_comment, file=self.outFile) # Copyright Notice copyright = '' copyright += '\n' copyright += '/***************************************************************************\n' copyright += ' *\n' copyright += ' * Copyright (c) 2015-2017 The Khronos Group Inc.\n' copyright += ' * Copyright (c) 2015-2017 Valve Corporation\n' copyright += ' * Copyright (c) 2015-2017 LunarG, Inc.\n' copyright += ' * Copyright (c) 2015-2017 Google Inc.\n' copyright += ' *\n' copyright += ' * Licensed under the Apache License, Version 2.0 (the "License");\n' copyright += ' * you may not use this file except in compliance with the License.\n' copyright += ' * You may obtain a copy of the License at\n' copyright += ' *\n' copyright += ' * http://www.apache.org/licenses/LICENSE-2.0\n' copyright += ' *\n' copyright += ' * Unless required by applicable law or agreed to in writing, software\n' copyright += ' * distributed under the License is distributed on an "AS IS" BASIS,\n' copyright += ' * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n' copyright += ' * See the License for the specific language governing permissions and\n' copyright += ' * limitations under the License.\n' copyright += ' *\n' copyright += ' * Author: Mark Lobodzinski \n' copyright += ' * Author: Courtney Goeltzenleuchter \n' copyright += ' * Author: Tobin Ehlis \n' copyright += ' * Author: Chris Forbes \n' copyright += ' * Author: John Zulauf\n' copyright += ' *\n' copyright += ' ****************************************************************************/\n' write(copyright, file=self.outFile) # # Write generated file content to output file def endFile(self): dest_file = '' dest_file += self.OutputDestFile() # Remove blank lines at EOF if dest_file.endswith('\n'): dest_file = dest_file[:-1] write(dest_file, file=self.outFile); # Finish processing in superclass OutputGenerator.endFile(self) # # Override parent class to be notified of the beginning of an extension def beginFeature(self, interface, emit): # Start processing in superclass OutputGenerator.beginFeature(self, interface, emit) self.featureExtraProtect = GetFeatureProtect(interface) if self.featureName == 'VK_VERSION_1_0' or self.featureName == 'VK_VERSION_1_1': return name = self.featureName nameElem = interface[0][1] name_define = nameElem.get('name') if 'EXTENSION_NAME' not in name_define: print("Error in vk.xml file -- extension name is not available") requires = interface.get('requires') if requires is not None: required_extensions = requires.split(',') else: required_extensions = list() info = { 'define': name_define, 'ifdef':self.featureExtraProtect, 'reqs':required_extensions } if interface.get('type') == 'instance': self.instance_extension_info[name] = info else: self.device_extension_info[name] = info # # Override parent class to be notified of the end of an extension def endFeature(self): # Finish processing in superclass OutputGenerator.endFeature(self) # # Grab group (e.g. C "enum" type) info to output for enum-string conversion helper def genGroup(self, groupinfo, groupName, alias): OutputGenerator.genGroup(self, groupinfo, groupName, alias) groupElem = groupinfo.elem # For enum_string_header if self.helper_file_type == 'enum_string_header': value_set = set() for elem in groupElem.findall('enum'): if elem.get('supported') != 'disabled' and elem.get('alias') is None: value_set.add(elem.get('name')) self.enum_output += self.GenerateEnumStringConversion(groupName, value_set) elif self.helper_file_type == 'object_types_header': if groupName == 'VkDebugReportObjectTypeEXT': for elem in groupElem.findall('enum'): if elem.get('supported') != 'disabled': item_name = elem.get('name') self.debug_report_object_types.append(item_name) elif groupName == 'VkObjectType': for elem in groupElem.findall('enum'): if elem.get('supported') != 'disabled': item_name = elem.get('name') self.core_object_types.append(item_name) # # Called for each type -- if the type is a struct/union, grab the metadata def genType(self, typeinfo, name, alias): OutputGenerator.genType(self, typeinfo, name, alias) typeElem = typeinfo.elem # If the type is a struct type, traverse the imbedded tags generating a structure. # Otherwise, emit the tag text. category = typeElem.get('category') if category == 'handle': if alias: self.object_type_aliases.append((name,alias)) else: self.object_types.append(name) elif (category == 'struct' or category == 'union'): self.structNames.append(name) self.genStruct(typeinfo, name, alias) # # Generate a VkStructureType based on a structure typename def genVkStructureType(self, typename): # Add underscore between lowercase then uppercase value = re.sub('([a-z0-9])([A-Z])', r'\1_\2', typename) # Change to uppercase value = value.upper() # Add STRUCTURE_TYPE_ return re.sub('VK_', 'VK_STRUCTURE_TYPE_', value) # # Check if the parameter passed in is a pointer def paramIsPointer(self, param): ispointer = False for elem in param: if ((elem.tag is not 'type') and (elem.tail is not None)) and '*' in elem.tail: ispointer = True return ispointer # # Check if the parameter passed in is a static array def paramIsStaticArray(self, param): isstaticarray = 0 paramname = param.find('name') if (paramname.tail is not None) and ('[' in paramname.tail): isstaticarray = paramname.tail.count('[') return isstaticarray # # Retrieve the type and name for a parameter def getTypeNameTuple(self, param): type = '' name = '' for elem in param: if elem.tag == 'type': type = noneStr(elem.text) elif elem.tag == 'name': name = noneStr(elem.text) return (type, name) # Extract length values from latexmath. Currently an inflexible solution that looks for specific # patterns that are found in vk.xml. Will need to be updated when new patterns are introduced. def parseLateXMath(self, source): name = 'ERROR' decoratedName = 'ERROR' if 'mathit' in source: # Matches expressions similar to 'latexmath:[\lceil{\mathit{rasterizationSamples} \over 32}\rceil]' match = re.match(r'latexmath\s*\:\s*\[\s*\\l(\w+)\s*\{\s*\\mathit\s*\{\s*(\w+)\s*\}\s*\\over\s*(\d+)\s*\}\s*\\r(\w+)\s*\]', source) if not match or match.group(1) != match.group(4): raise 'Unrecognized latexmath expression' name = match.group(2) # Need to add 1 for ceiling function; otherwise, the allocated packet # size will be less than needed during capture for some title which use # this in VkPipelineMultisampleStateCreateInfo. based on ceiling function # definition,it is '{0}%{1}?{0}/{1} + 1:{0}/{1}'.format(*match.group(2, 3)), # its value <= '{}/{} + 1'. if match.group(1) == 'ceil': decoratedName = '{}/{} + 1'.format(*match.group(2, 3)) else: decoratedName = '{}/{}'.format(*match.group(2, 3)) else: # Matches expressions similar to 'latexmath : [dataSize \over 4]' match = re.match(r'latexmath\s*\:\s*\[\s*(\\textrm\{)?(\w+)\}?\s*\\over\s*(\d+)\s*\]', source) name = match.group(2) decoratedName = '{}/{}'.format(*match.group(2, 3)) return name, decoratedName # # Retrieve the value of the len tag def getLen(self, param): result = None len = param.attrib.get('len') if len and len != 'null-terminated': # For string arrays, 'len' can look like 'count,null-terminated', indicating that we # have a null terminated array of strings. We strip the null-terminated from the # 'len' field and only return the parameter specifying the string count if 'null-terminated' in len: result = len.split(',')[0] else: result = len if 'latexmath' in len: param_type, param_name = self.getTypeNameTuple(param) len_name, result = self.parseLateXMath(len) # Spec has now notation for len attributes, using :: instead of platform specific pointer symbol result = str(result).replace('::', '->') return result # # Check if a structure is or contains a dispatchable (dispatchable = True) or # non-dispatchable (dispatchable = False) handle def TypeContainsObjectHandle(self, handle_type, dispatchable): if dispatchable: type_key = 'VK_DEFINE_HANDLE' else: type_key = 'VK_DEFINE_NON_DISPATCHABLE_HANDLE' handle = self.registry.tree.find("types/type/[name='" + handle_type + "'][@category='handle']") if handle is not None and handle.find('type').text == type_key: return True # if handle_type is a struct, search its members if handle_type in self.structNames: member_index = next((i for i, v in enumerate(self.structMembers) if v[0] == handle_type), None) if member_index is not None: for item in self.structMembers[member_index].members: handle = self.registry.tree.find("types/type/[name='" + item.type + "'][@category='handle']") if handle is not None and handle.find('type').text == type_key: return True return False # # Generate local ready-access data describing Vulkan structures and unions from the XML metadata def genStruct(self, typeinfo, typeName, alias): OutputGenerator.genStruct(self, typeinfo, typeName, alias) members = typeinfo.elem.findall('.//member') # Iterate over members once to get length parameters for arrays lens = set() for member in members: len = self.getLen(member) if len: lens.add(len) # Generate member info membersInfo = [] for member in members: # Get the member's type and name info = self.getTypeNameTuple(member) type = info[0] name = info[1] cdecl = self.makeCParamDecl(member, 1) # Process VkStructureType if type == 'VkStructureType': # Extract the required struct type value from the comments # embedded in the original text defining the 'typeinfo' element rawXml = etree.tostring(typeinfo.elem).decode('ascii') result = re.search(r'VK_STRUCTURE_TYPE_\w+', rawXml) if result: value = result.group(0) else: value = self.genVkStructureType(typeName) # Store the required type value self.structTypes[typeName] = self.StructType(name=name, value=value) # Store pointer/array/string info isstaticarray = self.paramIsStaticArray(member) membersInfo.append(self.CommandParam(type=type, name=name, ispointer=self.paramIsPointer(member), isstaticarray=isstaticarray, isconst=True if 'const' in cdecl else False, iscount=True if name in lens else False, len=self.getLen(member), extstructs=self.registry.validextensionstructs[typeName] if name == 'pNext' else None, cdecl=cdecl)) self.structMembers.append(self.StructMemberData(name=typeName, members=membersInfo, ifdef_protect=self.featureExtraProtect)) # # Enum_string_header: Create a routine to convert an enumerated value into a string def GenerateEnumStringConversion(self, groupName, value_list): outstring = '\n' outstring += 'static inline const char* string_%s(%s input_value)\n' % (groupName, groupName) outstring += '{\n' outstring += ' switch ((%s)input_value)\n' % groupName outstring += ' {\n' for item in value_list: outstring += ' case %s:\n' % item outstring += ' return "%s";\n' % item outstring += ' default:\n' outstring += ' return "Unhandled %s";\n' % groupName outstring += ' }\n' outstring += '}\n' return outstring # # Combine object types helper header file preamble with body text and return def GenerateObjectTypesHelperHeader(self): object_types_helper_header = '\n' object_types_helper_header += '#pragma once\n' object_types_helper_header += '\n' object_types_helper_header += '#include \n\n' object_types_helper_header += self.GenerateObjectTypesHeader() return object_types_helper_header # # Object types header: create object enum type header file def GenerateObjectTypesHeader(self): object_types_header = '' object_types_header += '// Object Type enum for validation layer internal object handling\n' object_types_header += 'typedef enum VulkanObjectType {\n' object_types_header += ' kVulkanObjectTypeUnknown = 0,\n' enum_num = 1 type_list = []; enum_entry_map = {} # Output enum definition as each handle is processed, saving the names to use for the conversion routine for item in self.object_types: fixup_name = item[2:] enum_entry = 'kVulkanObjectType%s' % fixup_name enum_entry_map[item] = enum_entry object_types_header += ' ' + enum_entry object_types_header += ' = %d,\n' % enum_num enum_num += 1 type_list.append(enum_entry) object_types_header += ' kVulkanObjectTypeMax = %d,\n' % enum_num object_types_header += ' // Aliases for backwards compatibilty of "promoted" types\n' for (name, alias) in self.object_type_aliases: fixup_name = name[2:] object_types_header += ' kVulkanObjectType{} = {},\n'.format(fixup_name, enum_entry_map[alias]) object_types_header += '} VulkanObjectType;\n\n' # Output name string helper object_types_header += '// Array of object name strings for OBJECT_TYPE enum conversion\n' object_types_header += 'static const char * const object_string[kVulkanObjectTypeMax] = {\n' object_types_header += ' "Unknown",\n' for item in self.object_types: fixup_name = item[2:] object_types_header += ' "%s",\n' % fixup_name object_types_header += '};\n' # Key creation helper for map comprehensions that convert between k and VK symbols def to_key(regex, raw_key): return re.search(regex, raw_key).group(1).lower().replace("_","") # Output a conversion routine from the layer object definitions to the debug report definitions # As the VK_DEBUG_REPORT types are not being updated, specify UNKNOWN for unmatched types object_types_header += '\n' object_types_header += '// Helper array to get Vulkan VK_EXT_debug_report object type enum from the internal layers version\n' object_types_header += 'const VkDebugReportObjectTypeEXT get_debug_report_enum[] = {\n' object_types_header += ' VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, // kVulkanObjectTypeUnknown\n' dbg_re = '^VK_DEBUG_REPORT_OBJECT_TYPE_(.*)_EXT$' dbg_map = {to_key(dbg_re, dbg) : dbg for dbg in self.debug_report_object_types} dbg_default = 'VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT' for object_type in type_list: vk_object_type = dbg_map.get(object_type.replace("kVulkanObjectType", "").lower(), dbg_default) object_types_header += ' %s, // %s\n' % (vk_object_type, object_type) object_types_header += '};\n' # Output a conversion routine from the layer object definitions to the core object type definitions # This will intentionally *fail* for unmatched types as the VK_OBJECT_TYPE list should match the kVulkanObjectType list object_types_header += '\n' object_types_header += '// Helper array to get Official Vulkan VkObjectType enum from the internal layers version\n' object_types_header += 'const VkObjectType get_object_type_enum[] = {\n' object_types_header += ' VK_OBJECT_TYPE_UNKNOWN, // kVulkanObjectTypeUnknown\n' vko_re = '^VK_OBJECT_TYPE_(.*)' vko_map = {to_key(vko_re, vko) : vko for vko in self.core_object_types} for object_type in type_list: vk_object_type = vko_map[object_type.replace("kVulkanObjectType", "").lower()] object_types_header += ' %s, // %s\n' % (vk_object_type, object_type) object_types_header += '};\n' # Create a function to convert from VkDebugReportObjectTypeEXT to VkObjectType object_types_header += '\n' object_types_header += '// Helper function to convert from VkDebugReportObjectTypeEXT to VkObjectType\n' object_types_header += 'static inline VkObjectType convertDebugReportObjectToCoreObject(VkDebugReportObjectTypeEXT debug_report_obj){\n' object_types_header += ' if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT) {\n' object_types_header += ' return VK_OBJECT_TYPE_UNKNOWN;\n' for core_object_type in self.core_object_types: core_target_type = core_object_type.replace("VK_OBJECT_TYPE_", "").lower() core_target_type = core_target_type.replace("_", "") for dr_object_type in self.debug_report_object_types: dr_target_type = dr_object_type.replace("VK_DEBUG_REPORT_OBJECT_TYPE_", "").lower() dr_target_type = dr_target_type[:-4] dr_target_type = dr_target_type.replace("_", "") if core_target_type == dr_target_type: object_types_header += ' } else if (debug_report_obj == %s) {\n' % dr_object_type object_types_header += ' return %s;\n' % core_object_type break object_types_header += ' }\n' object_types_header += ' return VK_OBJECT_TYPE_UNKNOWN;\n' object_types_header += '}\n' # Create a function to convert from VkObjectType to VkDebugReportObjectTypeEXT object_types_header += '\n' object_types_header += '// Helper function to convert from VkDebugReportObjectTypeEXT to VkObjectType\n' object_types_header += 'static inline VkDebugReportObjectTypeEXT convertCoreObjectToDebugReportObject(VkObjectType core_report_obj){\n' object_types_header += ' if (core_report_obj == VK_OBJECT_TYPE_UNKNOWN) {\n' object_types_header += ' return VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT;\n' for core_object_type in self.core_object_types: core_target_type = core_object_type.replace("VK_OBJECT_TYPE_", "").lower() core_target_type = core_target_type.replace("_", "") for dr_object_type in self.debug_report_object_types: dr_target_type = dr_object_type.replace("VK_DEBUG_REPORT_OBJECT_TYPE_", "").lower() dr_target_type = dr_target_type[:-4] dr_target_type = dr_target_type.replace("_", "") if core_target_type == dr_target_type: object_types_header += ' } else if (core_report_obj == %s) {\n' % core_object_type object_types_header += ' return %s;\n' % dr_object_type break object_types_header += ' }\n' object_types_header += ' return VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT;\n' object_types_header += '}\n' return object_types_header # # Create a helper file and return it as a string def OutputDestFile(self): if self.helper_file_type == 'object_types_header': return self.GenerateObjectTypesHelperHeader() else: return 'Bad Helper File Generator Option %s' % self.helper_file_type