blob: f5c045547a6460f72d3cbd33194bac1d26c8fb46 [file] [log] [blame]
#!/usr/bin/python3 -i
# Copyright 2013-2020 The Khronos Group Inc.
# SPDX-License-Identifier: Apache-2.0
import io,os,re,string,sys
from lxml import etree
def write(*args, **kwargs):
file = kwargs.pop('file', sys.stdout)
end = kwargs.pop('end', '\n')
file.write(' '.join([str(arg) for arg in args]))
# noneStr - returns string argument, or "" if argument is None.
# Used in converting lxml Elements into text.
# str - string to convert
def noneStr(str):
if (str):
return str
return ""
# matchAPIProfile - returns whether an API and profile
# being generated matches an element's profile
# api - string naming the API to match
# profile - string naming the profile to match
# elem - Element which (may) have 'api' and 'profile'
# attributes to match to.
# If a tag is not present in the Element, the corresponding API
# or profile always matches.
# Otherwise, the tag must exactly match the API or profile.
# Thus, if 'profile' = core:
# <remove> with no attribute will match
# <remove profile='core'> will match
# <remove profile='compatibility'> will not match
# Possible match conditions:
# Requested Element
# Profile Profile
# --------- --------
# None None Always matches
# 'string' None Always matches
# None 'string' Does not match. Can't generate multiple APIs
# or profiles, so if an API/profile constraint
# is present, it must be asked for explicitly.
# 'string' 'string' Strings must match
# ** In the future, we will allow regexes for the attributes,
# not just strings, so that api="^(gl|gles2)" will match. Even
# this isn't really quite enough, we might prefer something
# like "gl(core)|gles1(common-lite)".
def matchAPIProfile(api, profile, elem):
"""Match a requested API & profile name to a api & profile attributes of an Element"""
match = True
# Match 'api', if present
if ('api' in elem.attrib):
if (api == None):
raise UserWarning("No API requested, but 'api' attribute is present with value '" +
elem.get('api') + "'")
elif (api != elem.get('api')):
# Requested API doesn't match attribute
return False
if ('profile' in elem.attrib):
if (profile == None):
raise UserWarning("No profile requested, but 'profile' attribute is present with value '" +
elem.get('profile') + "'")
elif (profile != elem.get('profile')):
# Requested profile doesn't match attribute
return False
return True
# BaseInfo - base class for information about a registry feature
# (type/group/enum/command/API/extension).
# required - should this feature be defined during header generation
# (has it been removed by a profile or version)?
# declared - has this feature been defined already?
# elem - lxml.etree Element for this feature
# resetState() - reset required/declared to initial values. Used
# prior to generating a new API interface.
class BaseInfo:
"""Represents the state of a registry feature, used during API generation"""
def __init__(self, elem):
self.required = False
self.declared = False
self.elem = elem
def resetState(self):
self.required = False
self.declared = False
# TypeInfo - registry information about a type. No additional state
# beyond BaseInfo is required.
class TypeInfo(BaseInfo):
"""Represents the state of a registry type"""
def __init__(self, elem):
BaseInfo.__init__(self, elem)
# GroupInfo - registry information about a group of related enums.
# enums - dictionary of enum names which are in the group
class GroupInfo(BaseInfo):
"""Represents the state of a registry enumerant group"""
def __init__(self, elem):
BaseInfo.__init__(self, elem)
self.enums = {}
# EnumInfo - registry information about an enum
# type - numeric type of the value of the <enum> tag
# ( '' for GLint, 'u' for GLuint, 'ull' for GLuint64 )
class EnumInfo(BaseInfo):
"""Represents the state of a registry enum"""
def __init__(self, elem):
BaseInfo.__init__(self, elem)
self.type = elem.get('type')
if (self.type == None):
self.type = ''
# CmdInfo - registry information about a command
# glxtype - type of GLX protocol { None, 'render', 'single', 'vendor' }
# glxopcode - GLX protocol opcode { None, number }
# glxequiv - equivalent command at GLX dispatch level { None, string }
# vecequiv - equivalent vector form of a command taking multiple scalar args
# { None, string }
class CmdInfo(BaseInfo):
"""Represents the state of a registry command"""
def __init__(self, elem):
BaseInfo.__init__(self, elem)
self.glxtype = None
self.glxopcode = None
self.glxequiv = None
self.vecequiv = None
# FeatureInfo - registry information about an API <feature>
# or <extension>
# name - feature name string (e.g. 'GL_ARB_multitexture')
# number - feature version number (e.g. 1.2). <extension>
# features are unversioned and assigned version number 0.
# category - category, e.g. VERSION or ARB/KHR/OES/ETC/vendor
# emit - has this feature been defined already?
class FeatureInfo(BaseInfo):
"""Represents the state of an API feature (version/extension)"""
def __init__(self, elem):
BaseInfo.__init__(self, elem) = elem.get('name')
# Determine element category (vendor). Only works
# for <extension> elements.
if (elem.tag == 'feature'):
self.category = 'VERSION'
self.number = elem.get('number')
self.category ='_', 2)[1]
self.number = "0"
self.emit = False
# Primary sort key for regSortFeatures.
# Sorts by category of the feature name string:
# Core API features (those defined with a <feature> tag)
# ARB/KHR/OES (Khronos extensions)
# other (EXT/vendor extensions)
def regSortCategoryKey(feature):
if (feature.elem.tag == 'feature'):
return 0
elif (feature.category == 'ARB' or
feature.category == 'KHR' or
feature.category == 'OES'):
return 1
return 2
# Secondary sort key for regSortFeatures.
# Sorts by extension name.
def regSortNameKey(feature):
# Tertiary sort key for regSortFeatures.
# Sorts by feature version number. <extension>
# elements all have version number "0"
def regSortNumberKey(feature):
return feature.number
# regSortFeatures - default sort procedure for features.
# Sorts by primary key of feature category,
# then by feature name within the category,
# then by version number
def regSortFeatures(featureList):
featureList.sort(key = regSortNumberKey)
featureList.sort(key = regSortNameKey)
featureList.sort(key = regSortCategoryKey)
# GeneratorOptions - base class for options used during header production
# These options are target language independent, and used by
# Registry.apiGen() and by base OutputGenerator objects.
# Members
# filename - name of file to generate, or None to write to stdout.
# apiname - string matching <api> 'apiname' attribute, e.g. 'gl'.
# profile - string specifying API profile , e.g. 'core', or None.
# versions - regex matching API versions to process interfaces for.
# Normally '.*' or '[0-9]\.[0-9]' to match all defined versions.
# emitversions - regex matching API versions to actually emit
# interfaces for (though all requested versions are considered
# when deciding which interfaces to generate). For GL 4.3 glext.h,
# this might be '1\.[2-5]|[2-4]\.[0-9]'.
# defaultExtensions - If not None, a string which must in its
# entirety match the pattern in the "supported" attribute of
# the <extension>. Defaults to None. Usually the same as apiname.
# addExtensions - regex matching names of additional extensions
# to include. Defaults to None.
# removeExtensions - regex matching names of extensions to
# remove (after defaultExtensions and addExtensions). Defaults
# to None.
# sortProcedure - takes a list of FeatureInfo objects and sorts
# them in place to a preferred order in the generated output.
# Default is core API versions, ARB/KHR/OES extensions, all
# other extensions, alphabetically within each group.
# The regex patterns can be None or empty, in which case they match
# nothing.
class GeneratorOptions:
"""Represents options during header production from an API registry"""
def __init__(self,
filename = None,
apiname = None,
profile = None,
versions = '.*',
emitversions = '.*',
defaultExtensions = None,
addExtensions = None,
removeExtensions = None,
sortProcedure = regSortFeatures):
self.filename = filename
self.apiname = apiname
self.profile = profile
self.versions = self.emptyRegex(versions)
self.emitversions = self.emptyRegex(emitversions)
self.defaultExtensions = defaultExtensions
self.addExtensions = self.emptyRegex(addExtensions)
self.removeExtensions = self.emptyRegex(removeExtensions)
self.sortProcedure = sortProcedure
# Substitute a regular expression which matches no version
# or extension names for None or the empty string.
def emptyRegex(self,pat):
if (pat == None or pat == ''):
return '_nomatch_^'
return pat
# CGeneratorOptions - subclass of GeneratorOptions.
# Adds options used by COutputGenerator objects during C language header
# generation.
# Additional members
# prefixText - list of strings to prefix generated header with
# (usually a copyright statement + calling convention macros).
# protectFile - True if multiple inclusion protection should be
# generated (based on the filename) around the entire header.
# protectFeature - True if #ifndef..#endif protection should be
# generated around a feature interface in the header file.
# genFuncPointers - True if function pointer typedefs should be
# generated
# protectProto - Controls cpp protection around prototypes:
# False - no protection
# 'nonzero' - protectProtoStr must be defined to a nonzero value
# True - protectProtoStr must be defined
# protectProtoStr - #ifdef symbol to use around prototype
# declarations, if protected
# apicall - string to use for the function declaration prefix,
# such as APICALL on Windows.
# apientry - string to use for the calling convention macro,
# in typedefs, such as APIENTRY.
# apientryp - string to use for the calling convention macro
# in function pointer typedefs, such as APIENTRYP.
class CGeneratorOptions(GeneratorOptions):
"""Represents options during C header production from an API registry"""
def __init__(self,
filename = None,
apiname = None,
profile = None,
versions = '.*',
emitversions = '.*',
defaultExtensions = None,
addExtensions = None,
removeExtensions = None,
sortProcedure = regSortFeatures,
prefixText = "",
genFuncPointers = True,
protectFile = True,
protectFeature = True,
protectProto = True,
protectProtoStr = True,
apicall = '',
apientry = '',
apientryp = ''):
GeneratorOptions.__init__(self, filename, apiname, profile,
versions, emitversions, defaultExtensions,
addExtensions, removeExtensions, sortProcedure)
self.prefixText = prefixText
self.genFuncPointers = genFuncPointers
self.protectFile = protectFile
self.protectFeature = protectFeature
self.protectProto = protectProto
self.protectProtoStr = protectProtoStr
self.apicall = apicall
self.apientry = apientry
self.apientryp = apientryp
# OutputGenerator - base class for generating API interfaces.
# Manages basic logic, logging, and output file control
# Derived classes actually generate formatted output.
# ---- methods ----
# OutputGenerator(errFile, warnFile, diagFile)
# errFile, warnFile, diagFile - file handles to write errors,
# warnings, diagnostics to. May be None to not write.
# logMsg(level, *args) - log messages of different categories
# level - 'error', 'warn', or 'diag'. 'error' will also
# raise a UserWarning exception
# *args - print()-style arguments
# beginFile(genOpts) - start a new interface file
# genOpts - GeneratorOptions controlling what's generated and how
# endFile() - finish an interface file, closing it when done
# beginFeature(interface, emit) - write interface for a feature
# and tag generated features as having been done.
# interface - element for the <version> / <extension> to generate
# emit - actually write to the header only when True
# endFeature() - finish an interface.
# genType(typeinfo,name) - generate interface for a type
# typeinfo - TypeInfo for a type
# genEnum(enuminfo, name) - generate interface for an enum
# enuminfo - EnumInfo for an enum
# name - enum name
# genCmd(cmdinfo) - generate interface for a command
# cmdinfo - CmdInfo for a command
class OutputGenerator:
"""Generate specified API interfaces in a specific style, such as a C header"""
def __init__(self,
errFile = sys.stderr,
warnFile = sys.stderr,
diagFile = sys.stdout):
self.outFile = None
self.errFile = errFile
self.warnFile = warnFile
self.diagFile = diagFile
# Internal state
self.featureName = None
self.genOpts = None
# logMsg - write a message of different categories to different
# destinations.
# level -
# 'diag' (diagnostic, voluminous)
# 'warn' (warning)
# 'error' (fatal error - raises exception after logging)
# *args - print()-style arguments to direct to corresponding log
def logMsg(self, level, *args):
"""Log a message at the given level. Can be ignored or log to a file"""
if (level == 'error'):
strfile = io.StringIO()
write('ERROR:', *args, file=strfile)
if (self.errFile != None):
write(strfile.getvalue(), file=self.errFile)
raise UserWarning(strfile.getvalue())
elif (level == 'warn'):
if (self.warnFile != None):
write('WARNING:', *args, file=self.warnFile)
elif (level == 'diag'):
if (self.diagFile != None):
write('DIAG:', *args, file=self.diagFile)
raise UserWarning(
'*** FATAL ERROR in Generator.logMsg: unknown level:' + level)
def beginFile(self, genOpts):
self.genOpts = genOpts
# Open specified output file. Not done in constructor since a
# Generator can be used without writing to a file.
if (self.genOpts.filename != None):
self.outFile = open(self.genOpts.filename, 'w')
self.outFile = sys.stdout
def endFile(self):
self.errFile and self.errFile.flush()
self.warnFile and self.warnFile.flush()
self.diagFile and self.diagFile.flush()
if (self.outFile != sys.stdout and self.outFile != sys.stderr):
self.genOpts = None
def beginFeature(self, interface, emit):
self.emit = emit
self.featureName = interface.get('name')
# If there's an additional 'protect' attribute in the feature, save it
self.featureExtraProtect = interface.get('protect')
def endFeature(self):
# Derived classes responsible for emitting feature
self.featureName = None
self.featureExtraProtect = None
# Type generation
def genType(self, typeinfo, name):
if (self.featureName == None):
raise UserWarning('Attempt to generate type', name,
'when not in feature')
# Enumerant generation
def genEnum(self, enuminfo, name):
if (self.featureName == None):
raise UserWarning('Attempt to generate enum', name,
'when not in feature')
# Command generation
def genCmd(self, cmd, name):
if (self.featureName == None):
raise UserWarning('Attempt to generate command', name,
'when not in feature')
# COutputGenerator - subclass of OutputGenerator.
# Generates C-language API interfaces.
# ---- methods ----
# COutputGenerator(errFile, warnFile, diagFile) - args as for
# OutputGenerator. Defines additional internal state.
# makeCDecls(cmd) - return C prototype and function pointer typedef for a
# <command> Element, as a list of two strings
# cmd - Element for the <command>
# newline() - print a newline to the output file (utility function)
# ---- methods overriding base class ----
# beginFile(genOpts)
# endFile()
# beginFeature(interface, emit)
# endFeature()
# genType(typeinfo,name) - generate interface for a type
# genEnum(enuminfo, name)
# genCmd(cmdinfo)
class COutputGenerator(OutputGenerator):
"""Generate specified API interfaces in a specific style, such as a C header"""
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.typeBody = ''
self.enumBody = ''
self.cmdBody = ''
# makeCDecls - return C prototype and function pointer typedef for a
# command, as a two-element list of strings.
# cmd - Element containing a <command> tag
def makeCDecls(self, cmd):
"""Generate C function pointer typedef for <command> Element"""
proto = cmd.find('proto')
params = cmd.findall('param')
# Begin accumulating prototype and typedef strings
pdecl = self.genOpts.apicall
tdecl = 'typedef '
# Insert the function return type/name.
# For prototypes, add APIENTRY macro before the name
# For typedefs, add (APIENTRYP <name>) around the name and
# use the PFNGLCMDNAMEPROC nameng convention.
# Done by walking the tree for <proto> element by element.
# lxml.etree has elem.text followed by (elem[i], elem[i].tail)
# for each child element and any following text
# Leading text
pdecl += noneStr(proto.text)
tdecl += noneStr(proto.text)
# For each child element, if it's a <name> wrap in appropriate
# declaration. Otherwise append its contents and tail contents.
for elem in proto:
text = noneStr(elem.text)
tail = noneStr(elem.tail)
if (elem.tag == 'name'):
pdecl += self.genOpts.apientry + text + tail
tdecl += '(' + self.genOpts.apientryp + 'PFN' + text.upper() + 'PROC' + tail + ')'
pdecl += text + tail
tdecl += text + tail
# Now add the parameter declaration list, which is identical
# for prototypes and typedefs. Concatenate all the text from
# a <param> node without the tags. No tree walking required
# since all tags are ignored.
n = len(params)
paramdecl = ' ('
if n > 0:
for i in range(0,n):
paramdecl += ''.join([t for t in params[i].itertext()])
if (i < n - 1):
paramdecl += ', '
paramdecl += 'void'
paramdecl += ');\n';
return [ pdecl + paramdecl, tdecl + paramdecl ]
def newline(self):
write('', file=self.outFile)
def beginFile(self, genOpts):
OutputGenerator.beginFile(self, genOpts)
# C-specific
# Multiple inclusion protection & C++ wrappers.
if (genOpts.protectFile and self.genOpts.filename):
headerSym = '__' + self.genOpts.apiname + '_' + re.sub('\.h', '_h_', os.path.basename(self.genOpts.filename))
write('#ifndef', headerSym, file=self.outFile)
write('#define', headerSym, '1', file=self.outFile)
write('#ifdef __cplusplus', file=self.outFile)
write('extern "C" {', file=self.outFile)
write('#endif', file=self.outFile)
# User-supplied prefix text, if any (list of strings)
if (genOpts.prefixText):
for s in genOpts.prefixText:
write(s, file=self.outFile)
# Some boilerplate describing what was generated - this
# will probably be removed later since the extensions
# pattern may be very long.
write('/* Generated C header for:', file=self.outFile)
write(' * API:', genOpts.apiname, file=self.outFile)
if (genOpts.profile):
write(' * Profile:', genOpts.profile, file=self.outFile)
write(' * Versions considered:', genOpts.versions, file=self.outFile)
write(' * Versions emitted:', genOpts.emitversions, file=self.outFile)
write(' * Default extensions included:', genOpts.defaultExtensions, file=self.outFile)
write(' * Additional extensions included:', genOpts.addExtensions, file=self.outFile)
write(' * Extensions removed:', genOpts.removeExtensions, file=self.outFile)
write(' */', file=self.outFile)
def endFile(self):
# C-specific
# Finish C++ wrapper and multiple inclusion protection
write('#ifdef __cplusplus', file=self.outFile)
write('}', file=self.outFile)
write('#endif', file=self.outFile)
if (self.genOpts.protectFile and self.genOpts.filename):
write('#endif', file=self.outFile)
# Finish processing in superclass
def beginFeature(self, interface, emit):
# Start processing in superclass
OutputGenerator.beginFeature(self, interface, emit)
# C-specific
# Accumulate types, enums, function pointer typedefs, end function
# prototypes separately for this feature. They're only printed in
# endFeature().
self.typeBody = ''
self.enumBody = ''
self.cmdPointerBody = ''
self.cmdBody = ''
def endFeature(self):
# C-specific
# Actually write the interface to the output file.
if (self.emit):
if (self.genOpts.protectFeature):
write('#ifndef', self.featureName, file=self.outFile)
write('#define', self.featureName, '1', file=self.outFile)
if (self.typeBody != ''):
write(self.typeBody, end='', file=self.outFile)
# Don't add additional protection for derived type declarations,
# which may be needed by other features later on.
if (self.featureExtraProtect != None):
write('#ifdef', self.featureExtraProtect, file=self.outFile)
if (self.enumBody != ''):
write(self.enumBody, end='', file=self.outFile)
if (self.genOpts.genFuncPointers and self.cmdPointerBody != ''):
write(self.cmdPointerBody, end='', file=self.outFile)
if (self.cmdBody != ''):
if (self.genOpts.protectProto == True):
prefix = '#ifdef ' + self.genOpts.protectProtoStr + '\n'
suffix = '#endif\n'
elif (self.genOpts.protectProto == 'nonzero'):
prefix = '#if ' + self.genOpts.protectProtoStr + '\n'
suffix = '#endif\n'
elif (self.genOpts.protectProto == False):
prefix = ''
suffix = ''
'*** Unrecognized value for protectProto:',
'not generating prototype wrappers')
prefix = ''
suffix = ''
write(prefix + self.cmdBody + suffix, end='', file=self.outFile)
if (self.featureExtraProtect != None):
write('#endif /*', self.featureExtraProtect, '*/', file=self.outFile)
if (self.genOpts.protectFeature):
write('#endif /*', self.featureName, '*/', file=self.outFile)
# Finish processing in superclass
# Type generation
def genType(self, typeinfo, name):
OutputGenerator.genType(self, typeinfo, name)
# Replace <apientry /> tags with an APIENTRY-style string
# (from self.genOpts). Copy other text through unchanged.
# If the resulting text is an empty string, don't emit it.
typeElem = typeinfo.elem
s = noneStr(typeElem.text)
for elem in typeElem:
if (elem.tag == 'apientry'):
s += self.genOpts.apientry + noneStr(elem.tail)
s += noneStr(elem.text) + noneStr(elem.tail)
if (len(s) > 0):
self.typeBody += s + '\n'
# Enumerant generation
def genEnum(self, enuminfo, name):
OutputGenerator.genEnum(self, enuminfo, name)
# EnumInfo.type is a C value suffix (e.g. u, ull)
self.enumBody += '#define ' + name.ljust(33) + ' ' + enuminfo.elem.get('value')
# Handle non-integer 'type' fields by using it as the C value suffix
t = enuminfo.elem.get('type')
if (t != '' and t != 'i'):
self.enumBody += enuminfo.type
self.enumBody += '\n'
# Command generation
def genCmd(self, cmdinfo, name):
OutputGenerator.genCmd(self, cmdinfo, name)
decls = self.makeCDecls(cmdinfo.elem)
self.cmdBody += decls[0]
if (self.genOpts.genFuncPointers):
self.cmdPointerBody += decls[1]
# Registry - object representing an API registry, loaded from an XML file
# Members
# tree - ElementTree containing the root <registry>
# typedict - dictionary of TypeInfo objects keyed by type name
# groupdict - dictionary of GroupInfo objects keyed by group name
# enumdict - dictionary of EnumInfo objects keyed by enum name
# cmddict - dictionary of CmdInfo objects keyed by command name
# apidict - dictionary of <api> Elements keyed by API name
# extensions - list of <extension> Elements
# extdict - dictionary of <extension> Elements keyed by extension name
# gen - OutputGenerator object used to write headers / messages
# genOpts - GeneratorOptions object used to control which
# fetures to write and how to format them
# emitFeatures - True to actually emit features for a version / extension,
# or False to just treat them as emitted
# Public methods
# loadElementTree(etree) - load registry from specified ElementTree
# loadFile(filename) - load registry from XML file
# setGenerator(gen) - OutputGenerator to use
# parseTree() - parse the registry once loaded & create dictionaries
# dumpReg(maxlen, filehandle) - diagnostic to dump the dictionaries
# to specified file handle (default stdout). Truncates type /
# enum / command elements to maxlen characters (default 80)
# generator(g) - specify the output generator object
# apiGen(apiname, genOpts) - generate API headers for the API type
# and profile specified in genOpts, but only for the versions and
# extensions specified there.
# apiReset() - call between calls to apiGen() to reset internal state
# validateGroups() - call to verify that each <proto> or <param>
# with a 'group' attribute matches an actual existing group.
# Private methods
# addElementInfo(elem,info,infoName,dictionary) - add feature info to dict
# lookupElementInfo(fname,dictionary) - lookup feature info in dict
class Registry:
"""Represents an API registry loaded from XML"""
def __init__(self):
self.tree = None
self.typedict = {}
self.groupdict = {}
self.enumdict = {}
self.cmddict = {}
self.apidict = {}
self.extensions = []
self.extdict = {}
# A default output generator, so commands prior to apiGen can report
# errors via the generator object.
self.gen = OutputGenerator()
self.genOpts = None
self.emitFeatures = False
def loadElementTree(self, tree):
"""Load ElementTree into a Registry object and parse it"""
self.tree = tree
def loadFile(self, file):
"""Load an API registry XML file into a Registry object and parse it"""
self.tree = etree.parse(file)
def setGenerator(self, gen):
"""Specify output generator object. None restores the default generator"""
self.gen = gen
# addElementInfo - add information about an element to the
# corresponding dictionary
# elem - <type>/<group>/<enum>/<command>/<feature>/<extension> Element
# info - corresponding {Type|Group|Enum|Cmd|Feature}Info object
# infoName - 'type' / 'group' / 'enum' / 'command' / 'feature' / 'extension'
# dictionary - self.{type|group|enum|cmd|api|ext}dict
# If the Element has an 'api' attribute, the dictionary key is the
# tuple (name,api). If not, the key is the name. 'name' is an
# attribute of the Element
def addElementInfo(self, elem, info, infoName, dictionary):
if ('api' in elem.attrib):
key = (elem.get('name'),elem.get('api'))
key = elem.get('name')
if key in dictionary:
self.gen.logMsg('warn', '*** Attempt to redefine',
infoName, 'with key:', key)
dictionary[key] = info
# lookupElementInfo - find a {Type|Enum|Cmd}Info object by name.
# If an object qualified by API name exists, use that.
# fname - name of type / enum / command
# dictionary - self.{type|enum|cmd}dict
def lookupElementInfo(self, fname, dictionary):
key = (fname, self.genOpts.apiname)
if (key in dictionary):
# self.gen.logMsg('diag', 'Found API-specific element for feature', fname)
return dictionary[key]
elif (fname in dictionary):
# self.gen.logMsg('diag', 'Found generic element for feature', fname)
return dictionary[fname]
return None
def parseTree(self):
"""Parse the registry Element, once created"""
# This must be the Element for the root <registry>
self.reg = self.tree.getroot()
# Create dictionary of registry types from toplevel <types> tags
# and add 'name' attribute to each <type> tag (where missing)
# based on its <name> element.
# There's usually one <types> block; more are OK
# Required <type> attributes: 'name' or nested <name> tag contents
self.typedict = {}
for type in self.reg.findall('types/type'):
# If the <type> doesn't already have a 'name' attribute, set
# it from contents of its <name> tag.
if (type.get('name') == None):
type.attrib['name'] = type.find('name').text
self.addElementInfo(type, TypeInfo(type), 'type', self.typedict)
# Create dictionary of registry groups from toplevel <groups> tags.
# There's usually one <groups> block; more are OK.
# Required <group> attributes: 'name'
self.groupdict = {}
for group in self.reg.findall('groups/group'):
self.addElementInfo(group, GroupInfo(group), 'group', self.groupdict)
# Create dictionary of registry enums from toplevel <enums> tags
# There are usually many <enums> tags in different namespaces, but
# these are functional namespaces of the values, while the actual
# enum names all share the dictionary.
# Required <enums> attributes: 'name', 'value'
self.enumdict = {}
for enum in self.reg.findall('enums/enum'):
self.addElementInfo(enum, EnumInfo(enum), 'enum', self.enumdict)
# Create dictionary of registry commands from <command> tags
# and add 'name' attribute to each <command> tag (where missing)
# based on its <proto><name> element.
# There's usually only one <commands> block; more are OK.
# Required <command> attributes: 'name' or <proto><name> tag contents
self.cmddict = {}
for cmd in self.reg.findall('commands/command'):
# If the <command> doesn't already have a 'name' attribute, set
# it from contents of its <proto><name> tag.
if (cmd.get('name') == None):
cmd.attrib['name'] = cmd.find('proto/name').text
ci = CmdInfo(cmd)
self.addElementInfo(cmd, ci, 'command', self.cmddict)
# Create dictionaries of API and extension interfaces
# from toplevel <api> and <extension> tags.
self.apidict = {}
for feature in self.reg.findall('feature'):
ai = FeatureInfo(feature)
self.addElementInfo(feature, ai, 'feature', self.apidict)
self.extensions = self.reg.findall('extensions/extension')
self.extdict = {}
for feature in self.extensions:
ei = FeatureInfo(feature)
self.addElementInfo(feature, ei, 'extension', self.extdict)
def dumpReg(self, maxlen = 40, filehandle = sys.stdout):
"""Dump all the dictionaries constructed from the Registry object"""
write('***************************************', file=filehandle)
write(' ** Dumping Registry contents **', file=filehandle)
write('***************************************', file=filehandle)
write('// Types', file=filehandle)
for name in self.typedict:
tobj = self.typedict[name]
write(' Type', name, '->', etree.tostring(tobj.elem)[0:maxlen], file=filehandle)
write('// Groups', file=filehandle)
for name in self.groupdict:
gobj = self.groupdict[name]
write(' Group', name, '->', etree.tostring(gobj.elem)[0:maxlen], file=filehandle)
write('// Enums', file=filehandle)
for name in self.enumdict:
eobj = self.enumdict[name]
write(' Enum', name, '->', etree.tostring(eobj.elem)[0:maxlen], file=filehandle)
write('// Commands', file=filehandle)
for name in self.cmddict:
cobj = self.cmddict[name]
write(' Command', name, '->', etree.tostring(cobj.elem)[0:maxlen], file=filehandle)
write('// APIs', file=filehandle)
for key in self.apidict:
write(' API Version ', key, '->',
etree.tostring(self.apidict[key].elem)[0:maxlen], file=filehandle)
write('// Extensions', file=filehandle)
for key in self.extdict:
write(' Extension', key, '->',
etree.tostring(self.extdict[key].elem)[0:maxlen], file=filehandle)
# write('***************************************', file=filehandle)
# write(' ** Dumping XML ElementTree **', file=filehandle)
# write('***************************************', file=filehandle)
# write(etree.tostring(self.tree.getroot(),pretty_print=True), file=filehandle)
# typename - name of type
# required - boolean (to tag features as required or not)
def markTypeRequired(self, typename, required):
"""Require (along with its dependencies) or remove (but not its dependencies) a type"""
self.gen.logMsg('diag', '*** tagging type:', typename, '-> required =', required)
# Get TypeInfo object for <type> tag corresponding to typename
type = self.lookupElementInfo(typename, self.typedict)
if (type != None):
# Tag required type dependencies as required.
# This DOES NOT un-tag dependencies in a <remove> tag.
# See comments in markRequired() below for the reason.
if (required and ('requires' in type.elem.attrib)):
depType = type.elem.get('requires')
self.gen.logMsg('diag', '*** Generating dependent type',
depType, 'for type', typename)
self.markTypeRequired(depType, required)
type.required = required
self.gen.logMsg('warn', '*** type:', typename , 'IS NOT DEFINED')
# features - Element for <require> or <remove> tag
# required - boolean (to tag features as required or not)
def markRequired(self, features, required):
"""Require or remove features specified in the Element"""
self.gen.logMsg('diag', '*** markRequired (features = <too long to print>, required =', required, ')')
# Loop over types, enums, and commands in the tag
# @@ It would be possible to respect 'api' and 'profile' attributes
# in individual features, but that's not done yet.
for typeElem in features.findall('type'):
self.markTypeRequired(typeElem.get('name'), required)
for enumElem in features.findall('enum'):
name = enumElem.get('name')
self.gen.logMsg('diag', '*** tagging enum:', name, '-> required =', required)
enum = self.lookupElementInfo(name, self.enumdict)
if (enum != None):
enum.required = required
self.gen.logMsg('warn', '*** enum:', name , 'IS NOT DEFINED')
for cmdElem in features.findall('command'):
name = cmdElem.get('name')
self.gen.logMsg('diag', '*** tagging command:', name, '-> required =', required)
cmd = self.lookupElementInfo(name, self.cmddict)
if (cmd != None):
cmd.required = required
# Tag all parameter types of this command as required.
# This DOES NOT remove types of commands in a <remove>
# tag, because many other commands may use the same type.
# We could be more clever and reference count types,
# instead of using a boolean.
if (required):
# Look for <ptype> in entire <command> tree,
# not just immediate children
for ptype in cmd.elem.findall('.//ptype'):
self.gen.logMsg('diag', '*** markRequired: command implicitly requires dependent type', ptype.text)
self.markTypeRequired(ptype.text, required)
self.gen.logMsg('warn', '*** command:', name, 'IS NOT DEFINED')
# interface - Element for <version> or <extension>, containing
# <require> and <remove> tags
# api - string specifying API name being generated
# profile - string specifying API profile being generated
def requireAndRemoveFeatures(self, interface, api, profile):
"""Process <recquire> and <remove> tags for a <version> or <extension>"""
# <require> marks things that are required by this version/profile
for feature in interface.findall('require'):
if (matchAPIProfile(api, profile, feature)):
# <remove> marks things that are removed by this version/profile
for feature in interface.findall('remove'):
if (matchAPIProfile(api, profile, feature)):
# generateFeature - generate a single type / enum / command,
# and all its dependencies as needed.
# fname - name of feature (<type>/<enum>/<command>
# ftype - type of feature, 'type' | 'enum' | 'command'
# dictionary - of *Info objects - self.{type|enum|cmd}dict
# genProc - bound function pointer for self.gen.gen{Type|Enum|Cmd}
def generateFeature(self, fname, ftype, dictionary, genProc):
f = self.lookupElementInfo(fname, dictionary)
if (f == None):
# No such feature. This is an error, but reported earlier
self.gen.logMsg('diag', '*** No entry found for feature', fname,
# If feature isn't required, or has already been declared, return
if (not f.required):
self.gen.logMsg('diag', '*** Skipping', ftype, fname, '(not required)')
if (f.declared):
self.gen.logMsg('diag', '*** Skipping', ftype, fname, '(already declared)')
# Pull in dependent type declaration(s) of the feature.
# For types, there may be one in the 'required' attribute of the element
# For commands, there may be many in <ptype> tags within the element
# For enums, no dependencies are allowed (though perhasps if you
# have a uint64 enum, it should require GLuint64)
if (ftype == 'type'):
if ('requires' in f.elem.attrib):
depname = f.elem.get('requires')
self.gen.logMsg('diag', '*** Generating required dependent type',
self.generateFeature(depname, 'type', self.typedict,
elif (ftype == 'command'):
for ptype in f.elem.findall('.//ptype'):
depname = ptype.text
self.gen.logMsg('diag', '*** Generating required parameter type',
self.generateFeature(depname, 'type', self.typedict,
# Actually generate the type only if emitting declarations
if self.emitFeatures:
self.gen.logMsg('diag', '*** Emitting', ftype, 'decl for', fname)
genProc(f, fname)
self.gen.logMsg('diag', '*** Skipping', ftype, fname,
'(not emitting this feature)')
# Always mark feature declared, as though actually emitted
f.declared = True
# generateRequiredInterface - generate all interfaces required
# by an API version or extension
# interface - Element for <version> or <extension>
def generateRequiredInterface(self, interface):
"""Generate required C interface for specified API version/extension"""
# Loop over all features inside all <require> tags.
# <remove> tags are ignored (handled in pass 1).
for features in interface.findall('require'):
for t in features.findall('type'):
self.generateFeature(t.get('name'), 'type', self.typedict,
for e in features.findall('enum'):
self.generateFeature(e.get('name'), 'enum', self.enumdict,
for c in features.findall('command'):
self.generateFeature(c.get('name'), 'command', self.cmddict,
# apiGen(genOpts) - generate interface for specified versions
# genOpts - GeneratorOptions object with parameters used
# by the Generator object.
def apiGen(self, genOpts):
"""Generate interfaces for the specified API type and range of versions"""
self.gen.logMsg('diag', '*******************************************')
self.gen.logMsg('diag', ' Registry.apiGen file:', genOpts.filename,
'api:', genOpts.apiname,
'profile:', genOpts.profile)
self.gen.logMsg('diag', '*******************************************')
self.genOpts = genOpts
# Reset required/declared flags for all features
# Compile regexps used to select versions & extensions
regVersions = re.compile(self.genOpts.versions)
regEmitVersions = re.compile(self.genOpts.emitversions)
regAddExtensions = re.compile(self.genOpts.addExtensions)
regRemoveExtensions = re.compile(self.genOpts.removeExtensions)
# Get all matching API versions & add to list of FeatureInfo
features = []
apiMatch = False
for key in self.apidict:
fi = self.apidict[key]
api = fi.elem.get('api')
if (api == self.genOpts.apiname):
apiMatch = True
if (regVersions.match(fi.number)):
# Matches API & version #s being generated. Mark for
# emission and add to the features[] list .
# @@ Could use 'declared' instead of 'emit'?
fi.emit = (regEmitVersions.match(fi.number) != None)
if (not fi.emit):
self.gen.logMsg('diag', '*** NOT tagging feature api =', api,
'name =',, 'number =', fi.number,
'for emission (does not match emitversions pattern)')
self.gen.logMsg('diag', '*** NOT including feature api =', api,
'name =',, 'number =', fi.number,
'(does not match requested versions)')
self.gen.logMsg('diag', '*** NOT including feature api =', api,
'name =',,
'(does not match requested API)')
if (not apiMatch):
self.gen.logMsg('warn', '*** No matching API versions found!')
# Get all matching extensions & add to the list.
# Start with extensions tagged with 'api' pattern matching the API
# being generated. Add extensions matching the pattern specified in
# regExtensions, then remove extensions matching the pattern
# specified in regRemoveExtensions
for key in self.extdict:
ei = self.extdict[key]
extName =
include = False
# Include extension if defaultExtensions is not None and if the
# 'supported' attribute matches defaultExtensions. The regexp in
# 'supported' must exactly match defaultExtensions, so bracket
# it with ^(pat)$.
pat = '^(' + ei.elem.get('supported') + ')$'
if (self.genOpts.defaultExtensions and
re.match(pat, self.genOpts.defaultExtensions)):
self.gen.logMsg('diag', '*** Including extension',
extName, "(defaultExtensions matches the 'supported' attribute)")
include = True
# Include additional extensions if the extension name matches
# the regexp specified in the generator options. This allows
# forcing extensions into an interface even if they're not
# tagged appropriately in the registry.
if (regAddExtensions.match(extName) != None):
self.gen.logMsg('diag', '*** Including extension',
extName, '(matches explicitly requested extensions to add)')
include = True
# Remove extensions if the name matches the regexp specified
# in generator options. This allows forcing removal of
# extensions from an interface even if they're tagged that
# way in the registry.
if (regRemoveExtensions.match(extName) != None):
self.gen.logMsg('diag', '*** Removing extension',
extName, '(matches explicitly requested extensions to remove)')
include = False
# If the extension is to be included, add it to the
# extension features list.
if (include):
ei.emit = True
self.gen.logMsg('diag', '*** NOT including extension',
extName, '(does not match api attribute or explicitly requested extensions)')
# Sort the extension features list, if a sort procedure is defined
if (self.genOpts.sortProcedure):
# Pass 1: loop over requested API versions and extensions tagging
# types/commands/features as required (in an <require> block) or no
# longer required (in an <exclude> block). It is possible to remove
# a feature in one version and restore it later by requiring it in
# a later version.
# If a profile other than 'None' is being generated, it must
# match the profile attribute (if any) of the <require> and
# <remove> tags.
self.gen.logMsg('diag', '*** PASS 1: TAG FEATURES ********************************************')
for f in features:
self.gen.logMsg('diag', '*** PASS 1: Tagging required and removed features for',
self.requireAndRemoveFeatures(f.elem, self.genOpts.apiname, self.genOpts.profile)
# Pass 2: loop over specified API versions and extensions printing
# declarations for required things which haven't already been
# generated.
self.gen.logMsg('diag', '*** PASS 2: GENERATE INTERFACES FOR FEATURES ************************')
for f in features:
self.gen.logMsg('diag', '*** PASS 2: Generating interface for',
emit = self.emitFeatures = f.emit
if (not emit):
self.gen.logMsg('diag', '*** PASS 2: NOT declaring feature',
f.elem.get('name'), 'because it is not tagged for emission')
# Generate the interface (or just tag its elements as having been
# emitted, if they haven't been).
self.gen.beginFeature(f.elem, emit)
# apiReset - use between apiGen() calls to reset internal state
def apiReset(self):
"""Reset type/enum/command dictionaries before generating another API"""
for type in self.typedict:
for enum in self.enumdict:
for cmd in self.cmddict:
for cmd in self.apidict:
# validateGroups - check that group= attributes match actual groups
def validateGroups(self):
"""Validate group= attributes on <param> and <proto> tags"""
# Keep track of group names not in <group> tags
badGroup = {}
self.gen.logMsg('diag', '*** VALIDATING GROUP ATTRIBUTES ***')
for cmd in self.reg.findall('commands/command'):
proto = cmd.find('proto')
funcname = cmd.find('proto/name').text
if ('group' in proto.attrib.keys()):
group = proto.get('group')
# self.gen.logMsg('diag', '*** Command ', funcname, ' has return group ', group)
if (group not in self.groupdict.keys()):
# self.gen.logMsg('diag', '*** Command ', funcname, ' has UNKNOWN return group ', group)
if (group not in badGroup.keys()):
badGroup[group] = 1
badGroup[group] = badGroup[group] + 1
for param in cmd.findall('param'):
pname = param.find('name')
if (pname != None):
pname = pname.text
pname = type.get('name')
if ('group' in param.attrib.keys()):
group = param.get('group')
if (group not in self.groupdict.keys()):
# self.gen.logMsg('diag', '*** Command ', funcname, ' param ', pname, ' has UNKNOWN group ', group)
if (group not in badGroup.keys()):
badGroup[group] = 1
badGroup[group] = badGroup[group] + 1
if (len(badGroup.keys()) > 0):
self.gen.logMsg('diag', '*** SUMMARY OF UNRECOGNIZED GROUPS ***')
for key in sorted(badGroup.keys()):
self.gen.logMsg('diag', ' ', key, ' occurred ', badGroup[key], ' times')