Vulkan update/NVAPI support (#1511)

* First pass at incorporating nvapi into test harness.

* D3d12 Atomic Float Add via NVAPI working

* Dx12 atomic float appears to work.

* Atomic float add on Dx12.

* Added atomic64 feature addition to vk.
Fix correct output for atomic-float-byte-address.slang

* Disable atomic float failing tests.

* Upgraded VK headers.

* Detect atomic float availability on VK.

* Try to get test working for in64 atomic.

* Made HLSL prelude controlled via the render-test requirements.

* Added -enable-nvapi to premake.

* Fix D3D12Renderer when NVAPI is not available.

* Small improvements to VKRenderer.

* Improve atomic documentation in target-compatibility.md.

1 files changed, 269 insertions, 281 deletions

diff --git a/external/vulkan/registry/cgenerator.py b/external/vulkan/registry/cgenerator.py
index ab0c77981..11d54683b 100644
--- a/external/vulkan/registry/cgenerator.py
+++ b/external/vulkan/registry/cgenerator.py
@@ -1,164 +1,164 @@
 #!/usr/bin/python3 -i
 #
-# Copyright (c) 2013-2019 The Khronos Group Inc.
+# Copyright (c) 2013-2020 The Khronos Group 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.
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+import re
+from generator import (GeneratorOptions, OutputGenerator, noneStr,
+                       regSortFeatures, write)
 
-import os,re,sys,pdb
-from generator import *
 
-# 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 - If conditional protection should be generated
-#     around prototype declarations, set to either '#ifdef'
-#     to require opt-in (#ifdef protectProtoStr) or '#ifndef'
-#     to require opt-out (#ifndef protectProtoStr). Otherwise
-#     set to None.
-#   protectProtoStr - #ifdef/#ifndef symbol to use around prototype
-#     declarations, if protectProto is set
-#   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.
-#   directory - directory into which to generate include files
-#   indentFuncProto - True if prototype declarations should put each
-#     parameter on a separate line
-#   indentFuncPointer - True if typedefed function pointers should put each
-#     parameter on a separate line
-#   alignFuncParam - if nonzero and parameters are being put on a
-#     separate line, align parameter names at the specified column
 class CGeneratorOptions(GeneratorOptions):
-    """Represents options during C interface generation for headers"""
+    """CGeneratorOptions - subclass of GeneratorOptions.
+
+    Adds options used by COutputGenerator objects during C language header
+    generation."""
+
     def __init__(self,
-                 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,
-                 protectProto = None,
-                 protectProtoStr = None,
-                 apicall = '',
-                 apientry = '',
-                 apientryp = '',
-                 indentFuncProto = True,
-                 indentFuncPointer = False,
-                 alignFuncParam = 0):
-        GeneratorOptions.__init__(self, filename, directory, apiname, profile,
-                                  versions, emitversions, defaultExtensions,
-                                  addExtensions, removeExtensions,
-                                  emitExtensions, sortProcedure)
-        self.prefixText      = prefixText
+                 prefixText="",
+                 genFuncPointers=True,
+                 protectFile=True,
+                 protectFeature=True,
+                 protectProto=None,
+                 protectProtoStr=None,
+                 apicall='',
+                 apientry='',
+                 apientryp='',
+                 indentFuncProto=True,
+                 indentFuncPointer=False,
+                 alignFuncParam=0,
+                 genEnumBeginEndRange=False,
+                 genAliasMacro=False,
+                 aliasMacro='',
+                 **kwargs
+                 ):
+        """Constructor.
+        Additional parameters beyond parent class:
+
+        - 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 - If conditional protection should be generated
+        around prototype declarations, set to either '#ifdef'
+        to require opt-in (#ifdef protectProtoStr) or '#ifndef'
+        to require opt-out (#ifndef protectProtoStr). Otherwise
+        set to None.
+        - protectProtoStr - #ifdef/#ifndef symbol to use around prototype
+        declarations, if protectProto is set
+        - 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.
+        - indentFuncProto - True if prototype declarations should put each
+        parameter on a separate line
+        - indentFuncPointer - True if typedefed function pointers should put each
+        parameter on a separate line
+        - alignFuncParam - if nonzero and parameters are being put on a
+        separate line, align parameter names at the specified column
+        - genEnumBeginEndRange - True if BEGIN_RANGE / END_RANGE macros should
+        be generated for enumerated types
+        - genAliasMacro - True if the OpenXR alias macro should be generated
+        for aliased types (unclear what other circumstances this is useful)
+        - aliasMacro - alias macro to inject when genAliasMacro is True"""
+        GeneratorOptions.__init__(self, **kwargs)
+
+        self.prefixText = prefixText
+        """list of strings to prefix generated header with (usually a copyright statement + calling convention macros)."""
+
         self.genFuncPointers = genFuncPointers
-        self.protectFile     = protectFile
-        self.protectFeature  = protectFeature
-        self.protectProto    = protectProto
+        """True if function pointer typedefs should be generated"""
+
+        self.protectFile = protectFile
+        """True if multiple inclusion protection should be generated (based on the filename) around the entire header."""
+
+        self.protectFeature = protectFeature
+        """True if #ifndef..#endif protection should be generated around a feature interface in the header file."""
+
+        self.protectProto = protectProto
+        """If conditional protection should be generated around prototype declarations, set to either '#ifdef' to require opt-in (#ifdef protectProtoStr) or '#ifndef' to require opt-out (#ifndef protectProtoStr). Otherwise set to None."""
+
         self.protectProtoStr = protectProtoStr
-        self.apicall         = apicall
-        self.apientry        = apientry
-        self.apientryp       = apientryp
+        """#ifdef/#ifndef symbol to use around prototype declarations, if protectProto is set"""
+
+        self.apicall = apicall
+        """string to use for the function declaration prefix, such as APICALL on Windows."""
+
+        self.apientry = apientry
+        """string to use for the calling convention macro, in typedefs, such as APIENTRY."""
+
+        self.apientryp = apientryp
+        """string to use for the calling convention macro in function pointer typedefs, such as APIENTRYP."""
+
         self.indentFuncProto = indentFuncProto
+        """True if prototype declarations should put each parameter on a separate line"""
+
         self.indentFuncPointer = indentFuncPointer
-        self.alignFuncParam  = alignFuncParam
+        """True if typedefed function pointers should put each parameter on a separate line"""
+
+        self.alignFuncParam = alignFuncParam
+        """if nonzero and parameters are being put on a separate line, align parameter names at the specified column"""
+
+        self.genEnumBeginEndRange = genEnumBeginEndRange
+        """True if BEGIN_RANGE / END_RANGE macros should be generated for enumerated types"""
+
+        self.genAliasMacro = genAliasMacro
+        """True if the OpenXR alias macro should be generated for aliased types (unclear what other circumstances this is useful)"""
+
+        self.aliasMacro = aliasMacro
+        """alias macro to inject when genAliasMacro is True"""
+
+        self.codeGenerator = True
+        """True if this generator makes compilable code"""
+
 
-# COutputGenerator - subclass of OutputGenerator.
-# Generates C-language API interfaces.
-#
-# ---- methods ----
-# COutputGenerator(errFile, warnFile, diagFile) - args as for
-#   OutputGenerator. Defines additional internal state.
-# ---- methods overriding base class ----
-# beginFile(genOpts)
-# endFile()
-# beginFeature(interface, emit)
-# endFeature()
-# genType(typeinfo,name)
-# genStruct(typeinfo,name)
-# genGroup(groupinfo,name)
-# genEnum(enuminfo, name)
-# genCmd(cmdinfo)
 class COutputGenerator(OutputGenerator):
-    """Generate specified API interfaces in a specific style, such as a C header"""
+    """Generates C-language API interfaces."""
+
     # This is an ordered list of sections in the header file.
     TYPE_SECTIONS = ['include', 'define', 'basetype', 'handle', 'enum',
                      'group', 'bitmask', 'funcpointer', 'struct']
     ALL_SECTIONS = TYPE_SECTIONS + ['commandPointer', 'command']
-    def __init__(self,
-                 errFile = sys.stderr,
-                 warnFile = sys.stderr,
-                 diagFile = sys.stdout):
-        OutputGenerator.__init__(self, errFile, warnFile, diagFile)
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
         # Internal state - accumulators for different inner block text
-        self.sections = dict([(section, []) for section in self.ALL_SECTIONS])
-    #
+        self.sections = {section: [] for section in self.ALL_SECTIONS}
+        self.feature_not_empty = False
+        self.may_alias = None
+
     def beginFile(self, genOpts):
         OutputGenerator.beginFile(self, genOpts)
         # C-specific
         #
         # Multiple inclusion protection & C++ wrappers.
-        if (genOpts.protectFile and self.genOpts.filename):
-            headerSym = re.sub('\.h', '_h_',
+        if genOpts.protectFile and self.genOpts.filename:
+            headerSym = re.sub(r'\.h', '_h_',
                                os.path.basename(self.genOpts.filename)).upper()
             write('#ifndef', headerSym, file=self.outFile)
             write('#define', headerSym, '1', file=self.outFile)
             self.newline()
+
+        # User-supplied prefix text, if any (list of strings)
+        if genOpts.prefixText:
+            for s in genOpts.prefixText:
+                write(s, file=self.outFile)
+
+        # C++ extern wrapper - after prefix lines so they can add includes.
+        self.newline()
         write('#ifdef __cplusplus', file=self.outFile)
         write('extern "C" {', file=self.outFile)
         write('#endif', file=self.outFile)
         self.newline()
-        #
-        # 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(' * Extensions emitted:', genOpts.emitExtensions, file=self.outFile)
-        # write(' */', file=self.outFile)
+
     def endFile(self):
         # C-specific
         # Finish C++ wrapper and multiple inclusion protection
@@ -166,11 +166,12 @@ class COutputGenerator(OutputGenerator):
         write('#ifdef __cplusplus', file=self.outFile)
         write('}', file=self.outFile)
         write('#endif', file=self.outFile)
-        if (self.genOpts.protectFile and self.genOpts.filename):
+        if self.genOpts.protectFile and self.genOpts.filename:
             self.newline()
             write('#endif', file=self.outFile)
         # Finish processing in superclass
         OutputGenerator.endFile(self)
+
     def beginFeature(self, interface, emit):
         # Start processing in superclass
         OutputGenerator.beginFeature(self, interface, emit)
@@ -178,55 +179,60 @@ class COutputGenerator(OutputGenerator):
         # Accumulate includes, defines, types, enums, function pointer typedefs,
         # end function prototypes separately for this feature. They're only
         # printed in endFeature().
-        self.sections = dict([(section, []) for section in self.ALL_SECTIONS])
+        self.sections = {section: [] for section in self.ALL_SECTIONS}
+        self.feature_not_empty = False
+
     def endFeature(self):
+        "Actually write the interface to the output file."
         # C-specific
-        # Actually write the interface to the output file.
-        if (self.emit):
-            self.newline()
-            if (self.genOpts.protectFeature):
-                write('#ifndef', self.featureName, file=self.outFile)
-            # If type declarations are needed by other features based on
-            # this one, it may be necessary to suppress the ExtraProtect,
-            # or move it below the 'for section...' loop.
-            if (self.featureExtraProtect != None):
-                write('#ifdef', self.featureExtraProtect, file=self.outFile)
-            write('#define', self.featureName, '1', file=self.outFile)
-            for section in self.TYPE_SECTIONS:
-                contents = self.sections[section]
-                if contents:
-                    write('\n'.join(contents), file=self.outFile)
+        if self.emit:
+            if self.feature_not_empty:
+                if self.genOpts.conventions.writeFeature(self.featureExtraProtect, self.genOpts.filename):
                     self.newline()
-            if (self.genOpts.genFuncPointers and self.sections['commandPointer']):
-                write('\n'.join(self.sections['commandPointer']), file=self.outFile)
-                self.newline()
-            if (self.sections['command']):
-                if (self.genOpts.protectProto):
-                    write(self.genOpts.protectProto,
-                          self.genOpts.protectProtoStr, file=self.outFile)
-                write('\n'.join(self.sections['command']), end='', file=self.outFile)
-                if (self.genOpts.protectProto):
-                    write('#endif', file=self.outFile)
-                else:
+                    if self.genOpts.protectFeature:
+                        write('#ifndef', self.featureName, file=self.outFile)
+                    # If type declarations are needed by other features based on
+                    # this one, it may be necessary to suppress the ExtraProtect,
+                    # or move it below the 'for section...' loop.
+                    if self.featureExtraProtect is not None:
+                        write('#ifdef', self.featureExtraProtect, file=self.outFile)
                     self.newline()
-            if (self.featureExtraProtect != None):
-                write('#endif /*', self.featureExtraProtect, '*/', file=self.outFile)
-            if (self.genOpts.protectFeature):
-                write('#endif /*', self.featureName, '*/', file=self.outFile)
+                    write('#define', self.featureName, '1', file=self.outFile)
+                    for section in self.TYPE_SECTIONS:
+                        contents = self.sections[section]
+                        if contents:
+                            write('\n'.join(contents), file=self.outFile)
+                    if self.genOpts.genFuncPointers and self.sections['commandPointer']:
+                        write('\n'.join(self.sections['commandPointer']), file=self.outFile)
+                        self.newline()
+                    if self.sections['command']:
+                        if self.genOpts.protectProto:
+                            write(self.genOpts.protectProto,
+                                  self.genOpts.protectProtoStr, file=self.outFile)
+                        write('\n'.join(self.sections['command']), end='', file=self.outFile)
+                        if self.genOpts.protectProto:
+                            write('#endif', file=self.outFile)
+                        else:
+                            self.newline()
+                    if self.featureExtraProtect is not None:
+                        write('#endif /*', self.featureExtraProtect, '*/', file=self.outFile)
+                    if self.genOpts.protectFeature:
+                        write('#endif /*', self.featureName, '*/', file=self.outFile)
         # Finish processing in superclass
         OutputGenerator.endFeature(self)
-    #
-    # Append a definition to the specified section
+
     def appendSection(self, section, text):
+        "Append a definition to the specified section"
         # self.sections[section].append('SECTION: ' + section + '\n')
         self.sections[section].append(text)
-        # self.logMsg('diag', 'appendSection(section =', section, 'text =', text)
-    #
-    # Type generation
+        self.feature_not_empty = True
+
     def genType(self, typeinfo, name, alias):
+        "Generate type."
         OutputGenerator.genType(self, typeinfo, name, alias)
         typeElem = typeinfo.elem
 
+        # Vulkan:
         # Determine the category of the type, and the type section to add
         # its definition to.
         # 'funcpointer' is added to the 'struct' section as a workaround for
@@ -238,11 +244,12 @@ class COutputGenerator(OutputGenerator):
         else:
             section = category
 
-        if category == 'struct' or category == 'union':
+        if category in ('struct', 'union'):
             # If the type is a struct type, generate it using the
             # special-purpose generator.
             self.genStruct(typeinfo, name, alias)
         else:
+            # OpenXR: this section was not under 'else:' previously, just fell through
             if alias:
                 # If the type is an alias, just emit a typedef declaration
                 body = 'typedef ' + alias + ' ' + name + ';\n'
@@ -252,27 +259,69 @@ class COutputGenerator(OutputGenerator):
                 # If the resulting text is an empty string, don't emit it.
                 body = noneStr(typeElem.text)
                 for elem in typeElem:
-                    if (elem.tag == 'apientry'):
+                    if elem.tag == 'apientry':
                         body += self.genOpts.apientry + noneStr(elem.tail)
                     else:
                         body += noneStr(elem.text) + noneStr(elem.tail)
-
             if body:
                 # Add extra newline after multi-line entries.
                 if '\n' in body[0:-1]:
                     body += '\n'
                 self.appendSection(section, body)
-    #
-    # Struct (e.g. C "struct" type) generation.
-    # This is a special case of the <type> tag where the contents are
-    # interpreted as a set of <member> tags instead of freeform C
-    # 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.)
-    # If alias != None, then this struct aliases another; just
-    #   generate a typedef of that alias.
+
+    def genProtectString(self, protect_str):
+        """Generate protection string.
+
+        Protection strings are the strings defining the OS/Platform/Graphics
+        requirements for a given OpenXR command.  When generating the
+        language header files, we need to make sure the items specific to a
+        graphics API or OS platform are properly wrapped in #ifs."""
+        protect_if_str = ''
+        protect_end_str = ''
+        if not protect_str:
+            return (protect_if_str, protect_end_str)
+
+        if ',' in protect_str:
+            protect_list = protect_str.split(",")
+            protect_defs = ('defined(%s)' % d for d in protect_list)
+            protect_def_str = ' && '.join(protect_defs)
+            protect_if_str = '#if %s\n' % protect_def_str
+            protect_end_str = '#endif // %s\n' % protect_def_str
+        else:
+            protect_if_str = '#ifdef %s\n' % protect_str
+            protect_end_str = '#endif // %s\n' % protect_str
+
+        return (protect_if_str, protect_end_str)
+
+    def typeMayAlias(self, typeName):
+        if not self.may_alias:
+            # First time we've asked if a type may alias.
+            # So, let's populate the set of all names of types that may.
+
+            # Everyone with an explicit mayalias="true"
+            self.may_alias = set(typeName
+                                 for typeName, data in self.registry.typedict.items()
+                                 if data.elem.get('mayalias') == 'true')
+
+            # Every type mentioned in some other type's parentstruct attribute.
+            parent_structs = (otherType.elem.get('parentstruct')
+                              for otherType in self.registry.typedict.values())
+            self.may_alias.update(set(x for x in parent_structs
+                                      if x is not None))
+        return typeName in self.may_alias
+
     def genStruct(self, typeinfo, typeName, alias):
+        """Generate struct (e.g. C "struct" type).
+
+        This is a special case of the <type> tag where the contents are
+        interpreted as a set of <member> tags instead of freeform C
+        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.)
+
+        If alias is not None, then this struct aliases another; just
+        generate a typedef of that alias."""
         OutputGenerator.genStruct(self, typeinfo, typeName, alias)
 
         typeElem = typeinfo.elem
@@ -280,129 +329,68 @@ class COutputGenerator(OutputGenerator):
         if alias:
             body = 'typedef ' + alias + ' ' + typeName + ';\n'
         else:
-            body = 'typedef ' + typeElem.get('category') + ' ' + typeName + ' {\n'
+            body = ''
+            (protect_begin, protect_end) = self.genProtectString(typeElem.get('protect'))
+            if protect_begin:
+                body += protect_begin
+            body += 'typedef ' + typeElem.get('category')
 
-            targetLen = 0;
-            for member in typeElem.findall('.//member'):
-                targetLen = max(targetLen, self.getCParamTypeLength(member))
+            # This is an OpenXR-specific alternative where aliasing refers
+            # to an inheritance hierarchy of types rather than C-level type
+            # aliases.
+            if self.genOpts.genAliasMacro and self.typeMayAlias(typeName):
+                body += ' ' + self.genOpts.aliasMacro
+
+            body += ' ' + typeName + ' {\n'
+
+            targetLen = self.getMaxCParamTypeLength(typeinfo)
             for member in typeElem.findall('.//member'):
                 body += self.makeCParamDecl(member, targetLen + 4)
                 body += ';\n'
             body += '} ' + typeName + ';\n'
+            if protect_end:
+                body += protect_end
 
         self.appendSection('struct', body)
-    #
-    # Group (e.g. C "enum" type) generation.
-    # These are concatenated together with other types.
-    # If alias != None, it is the name of another group type
-    #   which aliases this type; just generate that alias.
-    def genGroup(self, groupinfo, groupName, alias = None):
+
+    def genGroup(self, groupinfo, groupName, alias=None):
+        """Generate groups (e.g. C "enum" type).
+
+        These are concatenated together with other types.
+
+        If alias is not None, it is the name of another group type
+        which aliases this type; just generate that alias."""
         OutputGenerator.genGroup(self, groupinfo, groupName, alias)
         groupElem = groupinfo.elem
 
-        if alias:
-            # If the group name is aliased, just emit a typedef declaration
-            # for the alias.
-            body = 'typedef ' + alias + ' ' + groupName + ';\n'
-        else:
-            self.logMsg('diag', 'CGenerator.genGroup group =', groupName, 'alias =', alias)
-
-            # Otherwise, emit an actual enumerated type declaration
-            expandName = re.sub(r'([0-9a-z_])([A-Z0-9])',r'\1_\2',groupName).upper()
-
-            expandPrefix = expandName
-            expandSuffix = ''
-            expandSuffixMatch = re.search(r'[A-Z][A-Z]+$',groupName)
-            if expandSuffixMatch:
-                expandSuffix = '_' + expandSuffixMatch.group()
-                # Strip off the suffix from the prefix
-                expandPrefix = expandName.rsplit(expandSuffix, 1)[0]
-
-            # Prefix
-            body = "\ntypedef enum " + groupName + " {\n"
-
-            # @@ Should use the type="bitmask" attribute instead
-            isEnum = ('FLAG_BITS' not in expandPrefix)
-
-            # Get a list of nested 'enum' tags.
-            enums = groupElem.findall('enum')
-
-            # Check for and report duplicates, and return a list with them
-            # removed.
-            enums = self.checkDuplicateEnums(enums)
-
-            # Loop over the nested 'enum' tags. Keep track of the minimum and
-            # maximum numeric values, if they can be determined; but only for
-            # core API enumerants, not extension enumerants. This is inferred
-            # by looking for 'extends' attributes.
-            minName = None
-
-            # Accumulate non-numeric enumerant values separately and append
-            # them following the numeric values, to allow for aliases.
-            # NOTE: this doesn't do a topological sort yet, so aliases of
-            # aliases can still get in the wrong order.
-            aliasText = ""
-
-            for elem in enums:
-                # Convert the value to an integer and use that to track min/max.
-                (numVal,strVal) = self.enumToValue(elem, True)
-                name = elem.get('name')
-
-                # Extension enumerants are only included if they are required
-                if self.isEnumRequired(elem):
-                    decl = "    " + name + " = " + strVal + ",\n"
-                    if numVal != None:
-                        body += decl
-                    else:
-                        aliasText += decl
-
-                # Don't track min/max for non-numbers (numVal == None)
-                if isEnum and numVal != None and elem.get('extends') is None:
-                    if minName == None:
-                        minName = maxName = name
-                        minValue = maxValue = numVal
-                    elif numVal < minValue:
-                        minName = name
-                        minValue = numVal
-                    elif numVal > maxValue:
-                        maxName = name
-                        maxValue = numVal
-
-            # Now append the non-numeric enumerant values
-            body += aliasText
-
-            # Generate min/max value tokens and a range-padding enum. Need some
-            # additional padding to generate correct names...
-            if isEnum:
-                body += "    " + expandPrefix + "_BEGIN_RANGE" + expandSuffix + " = " + minName + ",\n"
-                body += "    " + expandPrefix + "_END_RANGE" + expandSuffix + " = " + maxName + ",\n"
-                body += "    " + expandPrefix + "_RANGE_SIZE" + expandSuffix + " = (" + maxName + " - " + minName + " + 1),\n"
-
-            body += "    " + expandPrefix + "_MAX_ENUM" + expandSuffix + " = 0x7FFFFFFF\n"
-
-            # Postfix
-            body += "} " + groupName + ";"
-
         # After either enumerated type or alias paths, add the declaration
         # to the appropriate section for the group being defined.
         if groupElem.get('type') == 'bitmask':
             section = 'bitmask'
         else:
             section = 'group'
-        self.appendSection(section, body)
 
-    # Enumerant generation
-    # <enum> tags may specify their values in several ways, but are usually
-    # just integers.
+        if alias:
+            # If the group name is aliased, just emit a typedef declaration
+            # for the alias.
+            body = 'typedef ' + alias + ' ' + groupName + ';\n'
+            self.appendSection(section, body)
+        else:
+            (section, body) = self.buildEnumCDecl(self.genOpts.genEnumBeginEndRange, groupinfo, groupName)
+            self.appendSection(section, "\n" + body)
+
     def genEnum(self, enuminfo, name, alias):
+        """Generate enumerants.
+
+        <enum> tags may specify their values in several ways, but are usually
+        just integers."""
         OutputGenerator.genEnum(self, enuminfo, name, alias)
-        (numVal,strVal) = self.enumToValue(enuminfo.elem, False)
+        (_, strVal) = self.enumToValue(enuminfo.elem, False)
         body = '#define ' + name.ljust(33) + ' ' + strVal
         self.appendSection('enum', body)
 
-    #
-    # Command generation
     def genCmd(self, cmdinfo, name, alias):
+        "Command generation"
         OutputGenerator.genCmd(self, cmdinfo, name, alias)
 
         # if alias:
@@ -413,5 +401,5 @@ class COutputGenerator(OutputGenerator):
         prefix = ''
         decls = self.makeCDecls(cmdinfo.elem)
         self.appendSection('command', prefix + decls[0] + '\n')
-        if (self.genOpts.genFuncPointers):
+        if self.genOpts.genFuncPointers:
             self.appendSection('commandPointer', decls[1])