242 lines
8.0 KiB
Python
242 lines
8.0 KiB
Python
#!/usr/bin/env python3
|
|
|
|
# (C) Copyright 2015, NVIDIA CORPORATION.
|
|
# All Rights Reserved.
|
|
#
|
|
# Permission is hereby granted, free of charge, to any person obtaining a
|
|
# copy of this software and associated documentation files (the "Software"),
|
|
# to deal in the Software without restriction, including without limitation
|
|
# on the rights to use, copy, modify, merge, publish, distribute, sub
|
|
# license, and/or sell copies of the Software, and to permit persons to whom
|
|
# the Software is furnished to do so, subject to the following conditions:
|
|
#
|
|
# The above copyright notice and this permission notice (including the next
|
|
# paragraph) shall be included in all copies or substantial portions of the
|
|
# Software.
|
|
#
|
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
# FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
|
|
# IBM AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
# IN THE SOFTWARE.
|
|
#
|
|
# Authors:
|
|
# Kyle Brenneman <kbrenneman@nvidia.com>
|
|
|
|
import collections
|
|
import re
|
|
import sys
|
|
import xml.etree.ElementTree as etree
|
|
|
|
import os
|
|
GLAPI = os.path.join(os.path.dirname(__file__), "..", "glapi", "gen")
|
|
sys.path.insert(0, GLAPI)
|
|
import static_data
|
|
|
|
MAPI_TABLE_NUM_DYNAMIC = 4096
|
|
|
|
_LIBRARY_FEATURE_NAMES = {
|
|
# libGL and libGLdiapatch both include every function.
|
|
"gl" : None,
|
|
"gldispatch" : None,
|
|
"opengl" : frozenset(( "GL_VERSION_1_0", "GL_VERSION_1_1",
|
|
"GL_VERSION_1_2", "GL_VERSION_1_3", "GL_VERSION_1_4", "GL_VERSION_1_5",
|
|
"GL_VERSION_2_0", "GL_VERSION_2_1", "GL_VERSION_3_0", "GL_VERSION_3_1",
|
|
"GL_VERSION_3_2", "GL_VERSION_3_3", "GL_VERSION_4_0", "GL_VERSION_4_1",
|
|
"GL_VERSION_4_2", "GL_VERSION_4_3", "GL_VERSION_4_4", "GL_VERSION_4_5",
|
|
)),
|
|
"glesv1" : frozenset(("GL_VERSION_ES_CM_1_0", "GL_OES_point_size_array")),
|
|
"glesv2" : frozenset(("GL_ES_VERSION_2_0", "GL_ES_VERSION_3_0",
|
|
"GL_ES_VERSION_3_1", "GL_ES_VERSION_3_2",
|
|
)),
|
|
}
|
|
|
|
def getFunctions(xmlFiles):
|
|
"""
|
|
Reads an XML file and returns all of the functions defined in it.
|
|
|
|
xmlFile should be the path to Khronos's gl.xml file. The return value is a
|
|
sequence of FunctionDesc objects, ordered by slot number.
|
|
"""
|
|
roots = [ etree.parse(xmlFile).getroot() for xmlFile in xmlFiles ]
|
|
return getFunctionsFromRoots(roots)
|
|
|
|
def getFunctionsFromRoots(roots):
|
|
functions = {}
|
|
for root in roots:
|
|
for func in _getFunctionList(root):
|
|
functions[func.name] = func
|
|
functions = functions.values()
|
|
|
|
# Sort the function list by name.
|
|
functions = sorted(functions, key=lambda f: f.name)
|
|
|
|
# Lookup for fixed offset/slot functions and use it if available.
|
|
# Assign a slot number to each function. This isn't strictly necessary,
|
|
# since you can just look at the index in the list, but it makes it easier
|
|
# to include the slot when formatting output.
|
|
|
|
next_slot = 0
|
|
for i in range(len(functions)):
|
|
name = functions[i].name[2:]
|
|
|
|
if name in static_data.offsets:
|
|
functions[i] = functions[i]._replace(slot=static_data.offsets[name])
|
|
elif not name.endswith("ARB") and name + "ARB" in static_data.offsets:
|
|
functions[i] = functions[i]._replace(slot=static_data.offsets[name + "ARB"])
|
|
elif not name.endswith("EXT") and name + "EXT" in static_data.offsets:
|
|
functions[i] = functions[i]._replace(slot=static_data.offsets[name + "EXT"])
|
|
else:
|
|
functions[i] = functions[i]._replace(slot=next_slot)
|
|
next_slot += 1
|
|
|
|
return functions
|
|
|
|
def getExportNamesFromRoots(target, roots):
|
|
"""
|
|
Goes through the <feature> tags from gl.xml and returns a set of OpenGL
|
|
functions that a library should export.
|
|
|
|
target should be one of "gl", "gldispatch", "opengl", "glesv1", or
|
|
"glesv2".
|
|
"""
|
|
featureNames = _LIBRARY_FEATURE_NAMES[target]
|
|
if featureNames is None:
|
|
return set(func.name for func in getFunctionsFromRoots(roots))
|
|
|
|
names = set()
|
|
for root in roots:
|
|
features = []
|
|
for featElem in root.findall("feature"):
|
|
if featElem.get("name") in featureNames:
|
|
features.append(featElem)
|
|
for featElem in root.findall("extensions/extension"):
|
|
if featElem.get("name") in featureNames:
|
|
features.append(featElem)
|
|
for featElem in features:
|
|
for commandElem in featElem.findall("require/command"):
|
|
names.add(commandElem.get("name"))
|
|
return names
|
|
|
|
class FunctionArg(collections.namedtuple("FunctionArg", "type name")):
|
|
@property
|
|
def dec(self):
|
|
"""
|
|
Returns a "TYPE NAME" string, suitable for a function prototype.
|
|
"""
|
|
rv = str(self.type)
|
|
if not rv.endswith("*"):
|
|
rv += " "
|
|
rv += self.name
|
|
return rv
|
|
|
|
class FunctionDesc(collections.namedtuple("FunctionDesc", "name rt args slot")):
|
|
def hasReturn(self):
|
|
"""
|
|
Returns true if the function returns a value.
|
|
"""
|
|
return (self.rt != "void")
|
|
|
|
@property
|
|
def decArgs(self):
|
|
"""
|
|
Returns a string with the types and names of the arguments, as you
|
|
would use in a function declaration.
|
|
"""
|
|
if not self.args:
|
|
return "void"
|
|
else:
|
|
return ", ".join(arg.dec for arg in self.args)
|
|
|
|
@property
|
|
def callArgs(self):
|
|
"""
|
|
Returns a string with the names of the arguments, as you would use in a
|
|
function call.
|
|
"""
|
|
return ", ".join(arg.name for arg in self.args)
|
|
|
|
@property
|
|
def basename(self):
|
|
assert self.name.startswith("gl")
|
|
return self.name[2:]
|
|
|
|
def _getFunctionList(root):
|
|
for elem in root.findall("commands/command"):
|
|
yield _parseCommandElem(elem)
|
|
|
|
def _parseCommandElem(elem):
|
|
protoElem = elem.find("proto")
|
|
(rt, name) = _parseProtoElem(protoElem)
|
|
|
|
args = []
|
|
for ch in elem.findall("param"):
|
|
# <param> tags have the same format as a <proto> tag.
|
|
args.append(FunctionArg(*_parseProtoElem(ch)))
|
|
func = FunctionDesc(name, rt, tuple(args), slot=None)
|
|
|
|
return func
|
|
|
|
def _parseProtoElem(elem):
|
|
# If I just remove the tags and string the text together, I'll get valid C code.
|
|
text = _flattenText(elem)
|
|
text = text.strip()
|
|
m = re.match(r"^(.+)\b(\w+)(?:\s*\[\s*(\d*)\s*\])?$", text, re.S)
|
|
if m:
|
|
typename = _fixupTypeName(m.group(1))
|
|
name = m.group(2)
|
|
if m.group(3):
|
|
# HACK: glPathGlyphIndexRangeNV defines an argument like this:
|
|
# GLuint baseAndCount[2]
|
|
# Convert it to a pointer and hope for the best.
|
|
typename += "*"
|
|
return (typename, name)
|
|
else:
|
|
raise ValueError("Can't parse element %r -> %r" % (elem, text))
|
|
|
|
def _flattenText(elem):
|
|
"""
|
|
Returns the text in an element and all child elements, with the tags
|
|
removed.
|
|
"""
|
|
text = ""
|
|
if elem.text is not None:
|
|
text = elem.text
|
|
for ch in elem:
|
|
text += _flattenText(ch)
|
|
if ch.tail is not None:
|
|
text += ch.tail
|
|
return text
|
|
|
|
def _fixupTypeName(typeName):
|
|
"""
|
|
Converts a typename into a more consistent format.
|
|
"""
|
|
|
|
rv = typeName.strip()
|
|
|
|
# Replace "GLvoid" with just plain "void".
|
|
rv = re.sub(r"\bGLvoid\b", "void", rv)
|
|
|
|
# Remove the vendor suffixes from types that have a suffix-less version.
|
|
rv = re.sub(r"\b(GLhalf|GLintptr|GLsizeiptr|GLint64|GLuint64)(?:ARB|EXT|NV|ATI)\b", r"\1", rv)
|
|
|
|
rv = re.sub(r"\bGLDEBUGPROCKHR\b", "GLDEBUGPROC", rv)
|
|
|
|
# Clear out any leading and trailing whitespace.
|
|
rv = rv.strip()
|
|
|
|
# Remove any whitespace before a '*'
|
|
rv = re.sub(r"\s+\*", r"*", rv)
|
|
|
|
# Change "foo*" to "foo *"
|
|
rv = re.sub(r"([^\*])\*", r"\1 *", rv)
|
|
|
|
# Condense all whitespace into a single space.
|
|
rv = re.sub(r"\s+", " ", rv)
|
|
|
|
return rv
|
|
|