Commit ce562f9e authored by Kyle Brenneman's avatar Kyle Brenneman Committed by Emil Velikov

EGL: Implement the libglvnd interface for EGL (v3)

The new interface mostly just sits on top of the existing library.

The only change to the existing EGL code is to split the client
extension string into platform extensions and everything else. On
non-glvnd builds, eglQueryString will just concatenate the two strings.

The EGL dispatch stubs are all generated. The script is based on the one
used to generate entrypoints in libglvnd itself.

v2: [Kyle]
 - Rebased against master.
 - Reworked the EGL makefile to use separate libraries
 - Made the EGL code generation scripts work with Python 2 and 3.
 - Change gen_egl_dispatch.py to use argparse for the command line arguments.
 - Assorted formatting and style cleanup in the Python scripts.

v3: [Emil Velikov]
 - Rebase
 - Remove separate glvnd glx/egl configure toggles
Signed-off-by: default avatarEmil Velikov <emil.velikov@collabora.com>
parent 370df207
......@@ -1348,10 +1348,11 @@ dnl Libglvnd configuration
dnl
AC_ARG_ENABLE([libglvnd],
[AS_HELP_STRING([--enable-libglvnd],
[Build for libglvnd @<:@default=disabled@:>@])],
[Build GLX and EGL for libglvnd @<:@default=disabled@:>@])],
[enable_libglvnd="$enableval"],
[enable_libglvnd=no])
AM_CONDITIONAL(USE_LIBGLVND_GLX, test "x$enable_libglvnd" = xyes)
AM_CONDITIONAL(USE_LIBGLVND, test "x$enable_libglvnd" = xyes)
if test "x$enable_libglvnd" = xyes ; then
dnl XXX: update once we can handle more than libGL/glx.
dnl Namely: we should error out if neither of the glvnd enabled libraries
......@@ -1367,8 +1368,11 @@ if test "x$enable_libglvnd" = xyes ; then
;;
esac
PKG_CHECK_MODULES([GLVND], libglvnd >= 0.1.0)
DEFINES="${DEFINES} -DUSE_LIBGLVND_GLX=1"
PKG_CHECK_MODULES([GLVND], libglvnd >= 0.2.0)
PKG_CHECK_VAR(LIBGLVND_DATADIR, libglvnd, datadir)
AC_SUBST([LIBGLVND_DATADIR])
DEFINES="${DEFINES} -DUSE_LIBGLVND=1"
DEFAULT_GL_LIB_NAME=GLX_mesa
fi
......
......@@ -32,19 +32,16 @@ AM_CFLAGS = \
$(EGL_CFLAGS) \
-D_EGL_NATIVE_PLATFORM=$(EGL_NATIVE_PLATFORM)
lib_LTLIBRARIES = libEGL.la
libEGL_la_SOURCES = \
# Depending on whether libglvnd is enabled, we'll build the EGL library as
# either libEGL.so.1 or libEGL_mesa.so.0. Using an automake substitution
# in the variable names breaks "make dist" target, so use a conenience library
# instead.
noinst_LTLIBRARIES = libEGL_common.la
libEGL_common_la_SOURCES = \
$(LIBEGL_C_FILES)
libEGL_la_LIBADD = \
libEGL_common_la_LIBADD = \
$(EGL_LIB_DEPS)
libEGL_la_LDFLAGS = \
-no-undefined \
-version-number 1:0 \
$(BSYMBOLIC) \
$(GC_SECTIONS) \
$(LD_NO_UNDEFINED)
dri2_backend_FILES =
dri3_backend_FILES =
......@@ -52,7 +49,7 @@ dri3_backend_FILES =
if HAVE_PLATFORM_X11
AM_CFLAGS += -DHAVE_X11_PLATFORM
AM_CFLAGS += $(XCB_DRI2_CFLAGS)
libEGL_la_LIBADD += $(XCB_DRI2_LIBS)
libEGL_common_la_LIBADD += $(XCB_DRI2_LIBS)
dri2_backend_FILES += drivers/dri2/platform_x11.c
if HAVE_DRI3
......@@ -60,22 +57,22 @@ dri3_backend_FILES += \
drivers/dri2/platform_x11_dri3.c \
drivers/dri2/platform_x11_dri3.h
libEGL_la_LIBADD += $(top_builddir)/src/loader/libloader_dri3_helper.la
libEGL_common_la_LIBADD += $(top_builddir)/src/loader/libloader_dri3_helper.la
endif
endif
if HAVE_PLATFORM_WAYLAND
AM_CFLAGS += -DHAVE_WAYLAND_PLATFORM
AM_CFLAGS += $(WAYLAND_CFLAGS)
libEGL_la_LIBADD += $(WAYLAND_LIBS)
libEGL_la_LIBADD += $(LIBDRM_LIBS)
libEGL_la_LIBADD += $(top_builddir)/src/egl/wayland/wayland-drm/libwayland-drm.la
libEGL_common_la_LIBADD += $(WAYLAND_LIBS)
libEGL_common_la_LIBADD += $(LIBDRM_LIBS)
libEGL_common_la_LIBADD += $(top_builddir)/src/egl/wayland/wayland-drm/libwayland-drm.la
dri2_backend_FILES += drivers/dri2/platform_wayland.c
endif
if HAVE_EGL_PLATFORM_DRM
AM_CFLAGS += -DHAVE_DRM_PLATFORM
libEGL_la_LIBADD += $(top_builddir)/src/gbm/libgbm.la
libEGL_common_la_LIBADD += $(top_builddir)/src/gbm/libgbm.la
dri2_backend_FILES += drivers/dri2/platform_drm.c
endif
......@@ -87,7 +84,7 @@ endif
if HAVE_EGL_PLATFORM_ANDROID
AM_CFLAGS += -DHAVE_ANDROID_PLATFORM
AM_CFLAGS += $(ANDROID_CFLAGS)
libEGL_la_LIBADD += $(ANDROID_LIBS)
libEGL_common_la_LIBADD += $(ANDROID_LIBS)
dri2_backend_FILES += drivers/dri2/platform_android.c
endif
......@@ -101,13 +98,68 @@ AM_CFLAGS += \
-DDEFAULT_DRIVER_DIR=\"$(DRI_DRIVER_SEARCH_DIR)\" \
-D_EGL_BUILT_IN_DRIVER_DRI2
libEGL_la_SOURCES += \
libEGL_common_la_SOURCES += \
$(dri2_backend_core_FILES) \
$(dri2_backend_FILES) \
$(dri3_backend_FILES)
libEGL_la_LIBADD += $(top_builddir)/src/loader/libloader.la
libEGL_la_LIBADD += $(DLOPEN_LIBS) $(LIBDRM_LIBS) $(CLOCK_LIB)
libEGL_common_la_LIBADD += $(top_builddir)/src/loader/libloader.la
libEGL_common_la_LIBADD += $(DLOPEN_LIBS) $(LIBDRM_LIBS) $(CLOCK_LIB)
GLVND_GEN_DEPS = generate/gen_egl_dispatch.py \
generate/egl.xml generate/eglFunctionList.py generate/genCommon.py \
generate/egl_other.xml
PYTHON_GEN = $(AM_V_GEN)$(PYTHON2) $(PYTHON_FLAGS)
g_egldispatchstubs.c: $(GLVND_GEN_DEPS)
$(PYTHON_GEN) $(top_srcdir)/src/egl/generate/gen_egl_dispatch.py source \
$(top_srcdir)/src/egl/generate/eglFunctionList.py \
$(top_srcdir)/src/egl/generate/egl.xml \
$(top_srcdir)/src/egl/generate/egl_other.xml > $@
g_egldispatchstubs.h: $(GLVND_GEN_DEPS)
$(PYTHON_GEN) $(top_srcdir)/src/egl/generate/gen_egl_dispatch.py header \
$(top_srcdir)/src/egl/generate/eglFunctionList.py \
$(top_srcdir)/src/egl/generate/egl.xml \
$(top_srcdir)/src/egl/generate/egl_other.xml > $@
BUILT_SOURCES = g_egldispatchstubs.c g_egldispatchstubs.h
CLEANFILES = $(BUILT_SOURCES)
if USE_LIBGLVND
AM_CFLAGS += \
$(GLVND_CFLAGS)
vendorjsondir = @LIBGLVND_DATADIR@/glvnd/egl_vendor.d
vendorjson_DATA = main/50_mesa.json
lib_LTLIBRARIES = libEGL_mesa.la
libEGL_mesa_la_SOURCES = \
main/eglglvnd.c \
main/egldispatchstubs.h \
main/egldispatchstubs.c \
g_egldispatchstubs.c
libEGL_mesa_la_LIBADD = libEGL_common.la
libEGL_mesa_la_LDFLAGS = \
-no-undefined \
-version-number 0 \
$(BSYMBOLIC) \
$(GC_SECTIONS) \
$(LD_NO_UNDEFINED)
else # USE_LIBGLVND
lib_LTLIBRARIES = libEGL.la
libEGL_la_SOURCES =
libEGL_la_LIBADD = libEGL_common.la
libEGL_la_LDFLAGS = \
-no-undefined \
-version-number 1:0 \
$(BSYMBOLIC) \
$(GC_SECTIONS) \
$(LD_NO_UNDEFINED)
endif # USE_LIBGLVND
include $(top_srcdir)/install-lib-links.mk
......@@ -134,4 +186,6 @@ EXTRA_DIST = \
SConscript \
drivers/haiku \
main/egl.def \
main/README.txt
main/README.txt \
$(GLVND_GEN_DEPS) \
main/50_mesa.json
This source diff could not be displayed because it is too large. You can view the blob instead.
#!/usr/bin/env python
"""
Contains a list of EGL functions to generate dispatch functions for.
This is used from gen_egl_dispatch.py.
EGL_FUNCTIONS is a sequence of (name, eglData) pairs, where name is the name
of the function, and eglData is a dictionary containing data about that
function.
The values in the eglData dictionary are:
- method (string):
How to select a vendor library. See "Method values" below.
- prefix (string):
This string is prepended to the name of the dispatch function. If
unspecified, the default is "" (an empty string).
- static (boolean)
If True, this function should be declared static.
- "public" (boolean)
If True, the function should be exported from the library. Vendor libraries
generally should not use this.
- extension (string):
If specified, this is the name of a macro to check for before defining a
function. Used for checking for extension macros and such.
- retval (string):
If specified, this is a C expression with the default value to return if we
can't find a function to call. By default, it will try to guess from the
return type: EGL_NO_whatever for the various handle types, NULL for
pointers, and zero for everything else.
method values:
- "custom"
The dispatch stub will be hand-written instead of generated.
- "none"
No dispatch function exists at all, but the function should still have an
entry in the index array. This is for other functions that a stub may need
to call that are implemented in libEGL itself.
- "display"
Select a vendor from an EGLDisplay argument.
- "device"
Select a vendor from an EGLDeviceEXT argument.
- "current"
Select the vendor that owns the current context.
"""
def _eglFunc(name, method, static=None, public=False, inheader=None, prefix="dispatch_", extension=None, retval=None):
"""
A convenience function to define an entry in the EGL function list.
"""
if static is None:
static = (not public and method != "custom")
if inheader is None:
inheader = (not static)
values = {
"method" : method,
"prefix" : prefix,
"extension" : extension,
"retval" : retval,
"static" : static,
"public" : public,
"inheader" : inheader,
}
return (name, values)
EGL_FUNCTIONS = (
# EGL_VERSION_1_0
_eglFunc("eglChooseConfig", "none"),
_eglFunc("eglCopyBuffers", "none"),
_eglFunc("eglCreateContext", "none"),
_eglFunc("eglCreatePbufferSurface", "none"),
_eglFunc("eglCreatePixmapSurface", "none"),
_eglFunc("eglCreateWindowSurface", "none"),
_eglFunc("eglDestroyContext", "none"),
_eglFunc("eglDestroySurface", "none"),
_eglFunc("eglGetConfigAttrib", "none"),
_eglFunc("eglGetConfigs", "none"),
_eglFunc("eglQueryContext", "none"),
_eglFunc("eglQuerySurface", "none"),
_eglFunc("eglSwapBuffers", "none"),
_eglFunc("eglWaitGL", "none"),
_eglFunc("eglWaitNative", "none"),
_eglFunc("eglTerminate", "none"),
_eglFunc("eglInitialize", "none"),
_eglFunc("eglGetCurrentDisplay", "none"),
_eglFunc("eglGetCurrentSurface", "none"),
_eglFunc("eglGetDisplay", "none"),
_eglFunc("eglGetError", "none"),
_eglFunc("eglGetProcAddress", "none"),
_eglFunc("eglMakeCurrent", "none"),
_eglFunc("eglQueryString", "none"),
# EGL_VERSION_1_1
_eglFunc("eglBindTexImage", "none"),
_eglFunc("eglReleaseTexImage", "none"),
_eglFunc("eglSurfaceAttrib", "none"),
_eglFunc("eglSwapInterval", "none"),
# EGL_VERSION_1_2
_eglFunc("eglCreatePbufferFromClientBuffer", "none"),
_eglFunc("eglWaitClient", "none"),
_eglFunc("eglBindAPI", "none"),
_eglFunc("eglQueryAPI", "none"),
_eglFunc("eglReleaseThread", "none"),
# EGL_VERSION_1_4
_eglFunc("eglGetCurrentContext", "none"),
# EGL_VERSION_1_5
_eglFunc("eglCreateSync", "none"),
_eglFunc("eglDestroySync", "none"),
_eglFunc("eglClientWaitSync", "none"),
_eglFunc("eglGetSyncAttrib", "none"),
_eglFunc("eglCreateImage", "none"),
_eglFunc("eglDestroyImage", "none"),
_eglFunc("eglCreatePlatformWindowSurface", "none"),
_eglFunc("eglCreatePlatformPixmapSurface", "none"),
_eglFunc("eglWaitSync", "none"),
_eglFunc("eglGetPlatformDisplay", "none"),
# EGL_EXT_platform_base
_eglFunc("eglCreatePlatformWindowSurfaceEXT", "display"),
_eglFunc("eglCreatePlatformPixmapSurfaceEXT", "display"),
_eglFunc("eglGetPlatformDisplayEXT", "none"),
# TODO: Most of these extensions should be provided by the vendor
# libraries, not by libEGL. They're here now to make testing everything
# else easier.
# EGL_EXT_swap_buffers_with_damage
_eglFunc("eglSwapBuffersWithDamageEXT", "display"),
# KHR_EXT_swap_buffers_with_damage
_eglFunc("eglSwapBuffersWithDamageKHR", "display"),
# EGL_KHR_cl_event2
_eglFunc("eglCreateSync64KHR", "display"),
# EGL_KHR_fence_sync
_eglFunc("eglCreateSyncKHR", "display"),
_eglFunc("eglDestroySyncKHR", "display"),
_eglFunc("eglClientWaitSyncKHR", "display"),
_eglFunc("eglGetSyncAttribKHR", "display"),
# EGL_KHR_image
_eglFunc("eglCreateImageKHR", "display"),
_eglFunc("eglDestroyImageKHR", "display"),
# EGL_KHR_image_base
# eglCreateImageKHR already defined in EGL_KHR_image
# eglDestroyImageKHR already defined in EGL_KHR_image
# EGL_KHR_reusable_sync
_eglFunc("eglSignalSyncKHR", "display"),
# eglCreateSyncKHR already defined in EGL_KHR_fence_sync
# eglDestroySyncKHR already defined in EGL_KHR_fence_sync
# eglClientWaitSyncKHR already defined in EGL_KHR_fence_sync
# eglGetSyncAttribKHR already defined in EGL_KHR_fence_sync
# EGL_KHR_wait_sync
_eglFunc("eglWaitSyncKHR", "display"),
# EGL_MESA_drm_image
_eglFunc("eglCreateDRMImageMESA", "display"),
_eglFunc("eglExportDRMImageMESA", "display"),
# EGL_MESA_image_dma_buf_export
_eglFunc("eglExportDMABUFImageQueryMESA", "display"),
_eglFunc("eglExportDMABUFImageMESA", "display"),
# EGL_NOK_swap_region
_eglFunc("eglSwapBuffersRegionNOK", "display"),
# EGL_NV_post_sub_buffer
_eglFunc("eglPostSubBufferNV", "display"),
# EGL_WL_bind_wayland_display
_eglFunc("eglCreateWaylandBufferFromImageWL", "display"),
_eglFunc("eglUnbindWaylandDisplayWL", "display"),
_eglFunc("eglQueryWaylandBufferWL", "display"),
_eglFunc("eglBindWaylandDisplayWL", "display"),
# EGL_CHROMIUM_get_sync_values
_eglFunc("eglGetSyncValuesCHROMIUM", "display"),
# EGL_ANDROID_native_fence_sync
_eglFunc("eglDupNativeFenceFDANDROID", "display"),
)
<?xml version="1.0" encoding="UTF-8"?>
<registry>
<comment>
This file contains any EGL extension functions that are missing from
the normal egl.xml list.
</comment>
<commands namespace="EGL">
<!-- EGL_WL_bind_wayland_display -->
<command>
<proto>struct wl_buffer * <name>eglCreateWaylandBufferFromImageWL</name></proto>
<param><ptype>EGLDisplay</ptype> <name>dpy</name></param>
<param><ptype>EGLImage</ptype> <name>image</name></param>
</command>
<command>
<proto>EGLBoolean <name>eglUnbindWaylandDisplayWL</name></proto>
<param><ptype>EGLDisplay</ptype> <name>dpy</name></param>
<param><ptype>struct wl_display *</ptype> <name>display</name></param>
</command>
<command>
<proto>EGLBoolean <name>eglQueryWaylandBufferWL</name></proto>
<param><ptype>EGLDisplay</ptype> <name>dpy</name></param>
<param><ptype>struct wl_resource *</ptype> <name>buffer</name></param>
<param><ptype>EGLint</ptype> <name>attribute</name></param>
<param><ptype>EGLint *</ptype> <name>value</name></param>
</command>
<command>
<proto>EGLBoolean <name>eglBindWaylandDisplayWL</name></proto>
<param><ptype>EGLDisplay</ptype> <name>dpy</name></param>
<param><ptype>struct wl_display *</ptype> <name>display</name></param>
</command>
<!-- EGL_CHROMIUM_get_sync_values -->
<command>
<proto>EGLBoolean <name>eglGetSyncValuesCHROMIUM</name></proto>
<param><ptype>EGLDisplay</ptype> <name>display</name></param>
<param><ptype>EGLSurface</ptype> <name>surface</name></param>
<param><ptype>EGLuint64KHR *</ptype> <name>ust</name></param>
<param><ptype>EGLuint64KHR *</ptype> <name>msc</name></param>
<param><ptype>EGLuint64KHR *</ptype> <name>sbc</name></param>
</command>
</commands>
</registry>
#!/usr/bin/env python
# (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.cElementTree as etree
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)
# 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.
for i in range(len(functions)):
functions[i] = functions[i]._replace(slot=i)
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"\bGLvoid\b", "void", 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
#!/usr/bin/env python
# (C) Copyright 2016, 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>
"""
Generates dispatch functions for EGL.
The list of functions and arguments is read from the Khronos's XML files, with
additional information defined in the module eglFunctionList.
"""
import argparse
import collections
import imp
import sys
import textwrap
import genCommon
def main():
parser = argparse.ArgumentParser()
parser.add_argument("target", choices=("header", "source"),
help="Whether to build the source or header file.")
parser.add_argument("func_list_file", help="The function list .py file.")
parser.add_argument("xml_files", nargs="+", help="The XML files with the EGL function lists.")
args = parser.parse_args()
# The function list is a Python module, but it's specified on the command
# line.
eglFunctionList = imp.load_source("eglFunctionList", args.func_list_file)
xmlFunctions = genCommon.getFunctions(args.xml_files)
xmlByName = dict((f.name, f) for f in xmlFunctions)
functions = []
for (name, eglFunc) in eglFunctionList.EGL_FUNCTIONS:
func = xmlByName[name]
eglFunc = fixupEglFunc(func, eglFunc)
functions.append((func, eglFunc))
# Sort the function list by name.
functions = sorted(functions, key=lambda f: f[0].name)
if args.target == "header":
text = generateHeader(functions)
elif args.target == "source":
text = generateSource(functions)
sys.stdout.write(text)
def fixupEglFunc(func, eglFunc):
result = dict(eglFunc)
if result.get("prefix") is None:
result["prefix"] = ""
if result.get("extension") is not None:
text = "defined(" + result["extension"] + ")"
result["extension"] = text
if result["method"] in ("none", "custom"):
return result
if result["method"] not in ("display", "device", "current"):
raise ValueError("Invalid dispatch method %r for function %r" % (result["method"], func.name))
if func.hasReturn():