#
# Process commands, adding to appropriate dispatch tables
- def genCmd(self, cmdinfo, name):
- OutputGenerator.genCmd(self, cmdinfo, name)
+ def genCmd(self, cmdinfo, name, alias):
+ OutputGenerator.genCmd(self, cmdinfo, name, alias)
avoid_entries = ['vkCreateInstance',
'vkCreateDevice']
OutputGenerator.endFeature(self)
#
# Grab group (e.g. C "enum" type) info to output for enum-string conversion helper
- def genGroup(self, groupinfo, groupName):
- OutputGenerator.genGroup(self, groupinfo, groupName)
+ 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_list = []
for elem in groupElem.findall('enum'):
- if elem.get('supported') != 'disabled':
+ if elem.get('supported') != 'disabled' and elem.get('alias') == None:
item_name = elem.get('name')
# Avoid duplicates
if item_name not in value_list:
value_list.append(item_name)
if value_list is not None:
+ #if alias:
+ # self.enum_output += self.GenerateEnumStringConversion(alias, value_list)
+ #else:
self.enum_output += self.GenerateEnumStringConversion(groupName, value_list)
elif self.helper_file_type == 'object_types_header':
if groupName == 'VkDebugReportObjectTypeEXT':
#
# Called for each type -- if the type is a struct/union, grab the metadata
- def genType(self, typeinfo, name):
- OutputGenerator.genType(self, typeinfo, name)
+ 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 <member> tags generating a structure.
# Otherwise, emit the tag text.
self.object_types.append(name)
elif (category == 'struct' or category == 'union'):
self.structNames.append(name)
- self.genStruct(typeinfo, name)
+ self.genStruct(typeinfo, name, alias)
#
# Generate a VkStructureType based on a structure typename
def genVkStructureType(self, typename):
return False
#
# Generate local ready-access data describing Vulkan structures and unions from the XML metadata
- def genStruct(self, typeinfo, typeName):
- OutputGenerator.genStruct(self, typeinfo, typeName)
+ 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()
#
# Process commands, adding to appropriate dispatch tables
- def genCmd(self, cmdinfo, name):
- OutputGenerator.genCmd(self, cmdinfo, name)
+ def genCmd(self, cmdinfo, name, alias):
+ OutputGenerator.genCmd(self, cmdinfo, name, alias)
# Get first param type
params = cmdinfo.elem.findall('param')
self.sections[section].append(text)
#
# Type generation
- def genType(self, typeinfo, name):
+ def genType(self, typeinfo, name, alias):
pass
#
# Struct (e.g. C "struct" type) generation.
# tags - they are a declaration of a struct or union member.
# Only simple member declarations are supported (no nested
# structs etc.)
- def genStruct(self, typeinfo, typeName):
- OutputGenerator.genStruct(self, typeinfo, typeName)
+ def genStruct(self, typeinfo, typeName, alias):
+ OutputGenerator.genStruct(self, typeinfo, typeName, alias)
body = 'typedef ' + typeinfo.elem.get('category') + ' ' + typeName + ' {\n'
# paramdecl = self.makeCParamDecl(typeinfo.elem, self.genOpts.alignFuncParam)
for member in typeinfo.elem.findall('.//member'):
#
# Group (e.g. C "enum" type) generation.
# These are concatenated together with other types.
- def genGroup(self, groupinfo, groupName):
+ def genGroup(self, groupinfo, groupName, alias):
pass
# Enumerant generation
# <enum> tags may specify their values in several ways, but are usually
# just integers.
- def genEnum(self, enuminfo, name):
+ def genEnum(self, enuminfo, name, alias):
pass
#
# Command generation
- def genCmd(self, cmdinfo, name):
+ def genCmd(self, cmdinfo, name, alias):
decls = self.makeCDecls(cmdinfo.elem)
if self.header: # In the header declare all intercepts
self.appendSection('command', '')
if (self.featureExtraProtect != None):
self.intercepts += [ '#endif' ]
- OutputGenerator.genCmd(self, cmdinfo, name)
+ OutputGenerator.genCmd(self, cmdinfo, name, alias)
#
self.appendSection('command', '')
self.appendSection('command', 'static %s' % (decls[0][:-1]))
OutputGenerator.endFeature(self)
#
# Process enums, structs, etc.
- def genType(self, typeinfo, name):
- OutputGenerator.genType(self, typeinfo, name)
+ 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 <member> tags generating a structure.
# Otherwise, emit the tag text.
category = typeElem.get('category')
if (category == 'struct' or category == 'union'):
- self.genStruct(typeinfo, name)
+ self.genStruct(typeinfo, name, alias)
if category == 'handle':
self.object_types.append(name)
#
# <member> tags instead of freeform C type declarations. The <member> tags are just like
# <param> tags - they are a declaration of a struct or union member. Only simple member
# declarations are supported (no nested structs etc.)
- def genStruct(self, typeinfo, typeName):
- OutputGenerator.genStruct(self, typeinfo, typeName)
+ 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()
return paramdecl, param_pre_code, param_post_code
#
# Capture command parameter info needed to create, destroy, and validate objects
- def genCmd(self, cmdinfo, cmdname):
+ def genCmd(self, cmdinfo, cmdname, alias):
# Add struct-member type information to command parameter information
- OutputGenerator.genCmd(self, cmdinfo, cmdname)
+ OutputGenerator.genCmd(self, cmdinfo, cmdname, alias)
members = cmdinfo.elem.findall('.//param')
# Iterate over members once to get length parameters for arrays
lens = set()
OutputGenerator.endFeature(self)
#
# Type generation
- def genType(self, typeinfo, name):
- OutputGenerator.genType(self, typeinfo, name)
+ 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 <member> tags generating a structure. Otherwise, emit the tag text.
category = typeElem.get('category')
if (category == 'struct' or category == 'union'):
self.structNames.append(name)
- self.genStruct(typeinfo, name)
+ self.genStruct(typeinfo, name, alias)
elif (category == 'handle'):
self.handleTypes.add(name)
elif (category == 'bitmask'):
# This is a special case of the <type> tag where the contents are interpreted as a set of <member> tags instead of freeform C
# type declarations. The <member> tags are just like <param> tags - they are a declaration of a struct or union member.
# Only simple member declarations are supported (no nested structs etc.)
- def genStruct(self, typeinfo, typeName):
- OutputGenerator.genStruct(self, typeinfo, typeName)
+ def genStruct(self, typeinfo, typeName, alias):
+ if alias:
+ print("genStruct {} {}".format(typeName, alias))
+ OutputGenerator.genStruct(self, typeinfo, typeName, alias)
conditions = self.structMemberValidationConditions[typeName] if typeName in self.structMemberValidationConditions else None
members = typeinfo.elem.findall('.//member')
#
#
# Capture group (e.g. C "enum" type) info to be used for param check code generation.
# These are concatenated together with other types.
- def genGroup(self, groupinfo, groupName):
- OutputGenerator.genGroup(self, groupinfo, groupName)
+ def genGroup(self, groupinfo, groupName, alias):
+ if alias:
+ print("genGroup {} {}".format(groupName, alias))
+ OutputGenerator.genGroup(self, groupinfo, groupName, alias)
groupElem = groupinfo.elem
# Store the sType values
if groupName == 'VkStructureType':
self.enumValueLists += enum_entry
#
# Capture command parameter info to be used for param check code generation.
- def genCmd(self, cmdinfo, name):
- OutputGenerator.genCmd(self, cmdinfo, name)
+ def genCmd(self, cmdinfo, name, alias):
+ if alias:
+ print("genCmd {} {}".format(name, alias))
+ OutputGenerator.genCmd(self, cmdinfo, name, alias)
decls = self.makeCDecls(cmdinfo.elem)
typedef = decls[1]
typedef = typedef.split(')',1)[1]
self.sections[section].append(text)
#
# Type generation
- def genType(self, typeinfo, name):
+ def genType(self, typeinfo, name, alias):
pass
#
# Struct (e.g. C "struct" type) generation.
# tags - they are a declaration of a struct or union member.
# Only simple member declarations are supported (no nested
# structs etc.)
- def genStruct(self, typeinfo, typeName):
- OutputGenerator.genStruct(self, typeinfo, typeName)
+ def genStruct(self, typeinfo, typeName, alias):
+ OutputGenerator.genStruct(self, typeinfo, typeName, alias)
body = 'typedef ' + typeinfo.elem.get('category') + ' ' + typeName + ' {\n'
# paramdecl = self.makeCParamDecl(typeinfo.elem, self.genOpts.alignFuncParam)
for member in typeinfo.elem.findall('.//member'):
#
# Group (e.g. C "enum" type) generation.
# These are concatenated together with other types.
- def genGroup(self, groupinfo, groupName):
+ def genGroup(self, groupinfo, groupName, alias):
pass
# Enumerant generation
# <enum> tags may specify their values in several ways, but are usually
# just integers.
- def genEnum(self, enuminfo, name):
+ def genEnum(self, enuminfo, name, alias):
pass
#
# Command generation
- def genCmd(self, cmdinfo, name):
+ def genCmd(self, cmdinfo, name, alias):
# Commands shadowed by interface functions and are not implemented
special_functions = [
'vkGetDeviceProcAddr',
if (self.featureExtraProtect != None):
self.intercepts += [ '#endif' ]
- OutputGenerator.genCmd(self, cmdinfo, name)
+ OutputGenerator.genCmd(self, cmdinfo, name, alias)
#
decls = self.makeCDecls(cmdinfo.elem)
self.appendSection('command', '')
# Finish processing in superclass
OutputGenerator.endFeature(self)
#
- def genType(self, typeinfo, name):
- OutputGenerator.genType(self, typeinfo, name)
+ 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 <member> tags generating a structure.
# Otherwise, emit the tag text.
category = typeElem.get('category')
if (category == 'struct' or category == 'union'):
- self.genStruct(typeinfo, name)
+ self.genStruct(typeinfo, name, alias)
#
# Append a definition to the specified section
def appendSection(self, section, text):
# <member> tags instead of freeform C type declarations. The <member> tags are just like
# <param> tags - they are a declaration of a struct or union member. Only simple member
# declarations are supported (no nested structs etc.)
- def genStruct(self, typeinfo, typeName):
- OutputGenerator.genStruct(self, typeinfo, typeName)
+ 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()
return paramdecl, param_pre_code, param_post_code
#
# Capture command parameter info needed to wrap NDOs as well as handling some boilerplate code
- def genCmd(self, cmdinfo, cmdname):
+ def genCmd(self, cmdinfo, cmdname, alias):
# Add struct-member type information to command parameter information
- OutputGenerator.genCmd(self, cmdinfo, cmdname)
+ OutputGenerator.genCmd(self, cmdinfo, cmdname, alias)
members = cmdinfo.elem.findall('.//param')
# Iterate over members once to get length parameters for arrays
lens = set()