g_egldispatchstubs.[ch] are completely identical before and after this
patch.
Signed-off-by: Eric Engestrom <eric.engest...@intel.com>
---
src/egl/generate/eglFunctionList.py | 203 +++++++++++----------------
src/egl/generate/gen_egl_dispatch.py | 61 ++------
2 files changed, 91 insertions(+), 173 deletions(-)
diff --git a/src/egl/generate/eglFunctionList.py
b/src/egl/generate/eglFunctionList.py
index 667704eb2cb46fd06ff2..a480efca0d77a956dd78 100644
--- a/src/egl/generate/eglFunctionList.py
+++ b/src/egl/generate/eglFunctionList.py
@@ -5,36 +5,10 @@
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.
+EGL_FUNCTIONS is a sequence of (name, method) pairs, where name is the name
+of the function, and method is a string describing how to select a vendor
+library for 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.
@@ -53,158 +27,139 @@
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"),
+ ("eglChooseConfig", "none"),
+ ("eglCopyBuffers", "none"),
+ ("eglCreateContext", "none"),
+ ("eglCreatePbufferSurface", "none"),
+ ("eglCreatePixmapSurface", "none"),
+ ("eglCreateWindowSurface", "none"),
+ ("eglDestroyContext", "none"),
+ ("eglDestroySurface", "none"),
+ ("eglGetConfigAttrib", "none"),
+ ("eglGetConfigs", "none"),
+ ("eglQueryContext", "none"),
+ ("eglQuerySurface", "none"),
+ ("eglSwapBuffers", "none"),
+ ("eglWaitGL", "none"),
+ ("eglWaitNative", "none"),
+ ("eglTerminate", "none"),
+ ("eglInitialize", "none"),
- _eglFunc("eglGetCurrentDisplay", "none"),
- _eglFunc("eglGetCurrentSurface", "none"),
- _eglFunc("eglGetDisplay", "none"),
- _eglFunc("eglGetError", "none"),
- _eglFunc("eglGetProcAddress", "none"),
- _eglFunc("eglMakeCurrent", "none"),
- _eglFunc("eglQueryString", "none"),
+ ("eglGetCurrentDisplay", "none"),
+ ("eglGetCurrentSurface", "none"),
+ ("eglGetDisplay", "none"),
+ ("eglGetError", "none"),
+ ("eglGetProcAddress", "none"),
+ ("eglMakeCurrent", "none"),
+ ("eglQueryString", "none"),
# EGL_VERSION_1_1
- _eglFunc("eglBindTexImage", "none"),
- _eglFunc("eglReleaseTexImage", "none"),
- _eglFunc("eglSurfaceAttrib", "none"),
- _eglFunc("eglSwapInterval", "none"),
+ ("eglBindTexImage", "none"),
+ ("eglReleaseTexImage", "none"),
+ ("eglSurfaceAttrib", "none"),
+ ("eglSwapInterval", "none"),
# EGL_VERSION_1_2
- _eglFunc("eglCreatePbufferFromClientBuffer", "none"),
- _eglFunc("eglWaitClient", "none"),
- _eglFunc("eglBindAPI", "none"),
- _eglFunc("eglQueryAPI", "none"),
- _eglFunc("eglReleaseThread", "none"),
+ ("eglCreatePbufferFromClientBuffer", "none"),
+ ("eglWaitClient", "none"),
+ ("eglBindAPI", "none"),
+ ("eglQueryAPI", "none"),
+ ("eglReleaseThread", "none"),
# EGL_VERSION_1_4
- _eglFunc("eglGetCurrentContext", "none"),
+ ("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"),
+ ("eglCreateSync", "none"),
+ ("eglDestroySync", "none"),
+ ("eglClientWaitSync", "none"),
+ ("eglGetSyncAttrib", "none"),
+ ("eglCreateImage", "none"),
+ ("eglDestroyImage", "none"),
+ ("eglCreatePlatformWindowSurface", "none"),
+ ("eglCreatePlatformPixmapSurface", "none"),
+ ("eglWaitSync", "none"),
+ ("eglGetPlatformDisplay", "none"),
# EGL_EXT_platform_base
- _eglFunc("eglCreatePlatformWindowSurfaceEXT", "display"),
- _eglFunc("eglCreatePlatformPixmapSurfaceEXT", "display"),
- _eglFunc("eglGetPlatformDisplayEXT", "none"),
+ ("eglCreatePlatformWindowSurfaceEXT", "display"),
+ ("eglCreatePlatformPixmapSurfaceEXT", "display"),
+ ("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"),
+ ("eglSwapBuffersWithDamageEXT", "display"),
# KHR_EXT_swap_buffers_with_damage
- _eglFunc("eglSwapBuffersWithDamageKHR", "display"),
+ ("eglSwapBuffersWithDamageKHR", "display"),
# EGL_KHR_cl_event2
- _eglFunc("eglCreateSync64KHR", "display"),
+ ("eglCreateSync64KHR", "display"),
# EGL_KHR_fence_sync
- _eglFunc("eglCreateSyncKHR", "display"),
- _eglFunc("eglDestroySyncKHR", "display"),
- _eglFunc("eglClientWaitSyncKHR", "display"),
- _eglFunc("eglGetSyncAttribKHR", "display"),
+ ("eglCreateSyncKHR", "display"),
+ ("eglDestroySyncKHR", "display"),
+ ("eglClientWaitSyncKHR", "display"),
+ ("eglGetSyncAttribKHR", "display"),
# EGL_KHR_image
- _eglFunc("eglCreateImageKHR", "display"),
- _eglFunc("eglDestroyImageKHR", "display"),
+ ("eglCreateImageKHR", "display"),
+ ("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"),
+ ("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"),
+ ("eglWaitSyncKHR", "display"),
# EGL_MESA_drm_image
- _eglFunc("eglCreateDRMImageMESA", "display"),
- _eglFunc("eglExportDRMImageMESA", "display"),
+ ("eglCreateDRMImageMESA", "display"),
+ ("eglExportDRMImageMESA", "display"),
# EGL_MESA_image_dma_buf_export
- _eglFunc("eglExportDMABUFImageQueryMESA", "display"),
- _eglFunc("eglExportDMABUFImageMESA", "display"),
+ ("eglExportDMABUFImageQueryMESA", "display"),
+ ("eglExportDMABUFImageMESA", "display"),
# EGL_NOK_swap_region
- _eglFunc("eglSwapBuffersRegionNOK", "display"),
+ ("eglSwapBuffersRegionNOK", "display"),
# EGL_NV_post_sub_buffer
- _eglFunc("eglPostSubBufferNV", "display"),
+ ("eglPostSubBufferNV", "display"),
# EGL_WL_bind_wayland_display
- _eglFunc("eglCreateWaylandBufferFromImageWL", "display"),
- _eglFunc("eglUnbindWaylandDisplayWL", "display"),
- _eglFunc("eglQueryWaylandBufferWL", "display"),
- _eglFunc("eglBindWaylandDisplayWL", "display"),
+ ("eglCreateWaylandBufferFromImageWL", "display"),
+ ("eglUnbindWaylandDisplayWL", "display"),
+ ("eglQueryWaylandBufferWL", "display"),
+ ("eglBindWaylandDisplayWL", "display"),
# EGL_CHROMIUM_get_sync_values
- _eglFunc("eglGetSyncValuesCHROMIUM", "display"),
+ ("eglGetSyncValuesCHROMIUM", "display"),
# EGL_ANDROID_native_fence_sync
- _eglFunc("eglDupNativeFenceFDANDROID", "display"),
+ ("eglDupNativeFenceFDANDROID", "display"),
# EGL_EXT_image_dma_buf_import_modifiers
- _eglFunc("eglQueryDmaBufFormatsEXT", "display"),
- _eglFunc("eglQueryDmaBufModifiersEXT", "display"),
+ ("eglQueryDmaBufFormatsEXT", "display"),
+ ("eglQueryDmaBufModifiersEXT", "display"),
# EGL_EXT_device_base
- _eglFunc("eglQueryDeviceAttribEXT", "device"),
- _eglFunc("eglQueryDeviceStringEXT", "device"),
- _eglFunc("eglQueryDevicesEXT", "none"),
- _eglFunc("eglQueryDisplayAttribEXT", "display"),
+ ("eglQueryDeviceAttribEXT", "device"),
+ ("eglQueryDeviceStringEXT", "device"),
+ ("eglQueryDevicesEXT", "none"),
+ ("eglQueryDisplayAttribEXT", "display"),
)
diff --git a/src/egl/generate/gen_egl_dispatch.py
b/src/egl/generate/gen_egl_dispatch.py
index 0c4d2956eff28911336c..d40774ddd853a4de4140 100644
--- a/src/egl/generate/gen_egl_dispatch.py
+++ b/src/egl/generate/gen_egl_dispatch.py
@@ -56,9 +56,9 @@ def main():
xmlFunctions = genCommon.getFunctions(args.xml_files)
xmlByName = dict((f.name, f) for f in xmlFunctions)
functions = []
- for (name, eglFunc) in eglFunctionList.EGL_FUNCTIONS:
+ for (name, method) in eglFunctionList.EGL_FUNCTIONS:
func = xmlByName[name]
- eglFunc = fixupEglFunc(func, eglFunc)
+ eglFunc = fixupEglFunc(func, method)
functions.append((func, eglFunc))
# Sort the function list by name.
@@ -70,24 +70,17 @@ def main():
text = generateSource(functions)
sys.stdout.write(text)
-def fixupEglFunc(func, eglFunc):
- result = dict(eglFunc)
- if result.get("prefix") is None:
- result["prefix"] = ""
+def fixupEglFunc(func, method):
+ result = {"method": method}
- if result.get("extension") is not None:
- text = "defined(" + result["extension"] + ")"
- result["extension"] = text
-
- if result["method"] in ("none", "custom"):
+ if result["method"] is "none":
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():
- if result.get("retval") is None:
- result["retval"] = getDefaultReturnValue(func.rt)
+ result["retval"] = getDefaultReturnValue(func.rt)
return result
@@ -107,19 +100,11 @@ def generateHeader(functions):
""".lstrip("\n"))
text += "enum {\n"
- for (func, eglFunc) in functions:
- text += generateGuardBegin(func, eglFunc)
+ for (func, _) in functions:
text += " __EGL_DISPATCH_" + func.name + ",\n"
- text += generateGuardEnd(func, eglFunc)
text += " __EGL_DISPATCH_COUNT\n"
text += "};\n"
- for (func, eglFunc) in functions:
- if eglFunc["inheader"]:
- text += generateGuardBegin(func, eglFunc)
- text += "{f.rt} EGLAPIENTRY
{ex[prefix]}{f.name}({f.decArgs});\n".format(f=func, ex=eglFunc)
- text += generateGuardEnd(func, eglFunc)
-
text += textwrap.dedent(r"""
#ifdef __cplusplus
}
@@ -137,58 +122,36 @@ def generateSource(functions):
for (func, eglFunc) in functions:
if eglFunc["method"] not in ("custom", "none"):
- text += generateGuardBegin(func, eglFunc)
text += generateDispatchFunc(func, eglFunc)
- text += generateGuardEnd(func, eglFunc)
text += "\n"
text += "const char * const __EGL_DISPATCH_FUNC_NAMES[__EGL_DISPATCH_COUNT
+ 1] = {\n"
- for (func, eglFunc) in functions:
- text += generateGuardBegin(func, eglFunc)
+ for (func, _) in functions:
text += ' "' + func.name + '",\n'
- text += generateGuardEnd(func, eglFunc)
text += " NULL\n"
text += "};\n"
text += "const __eglMustCastToProperFunctionPointerType
__EGL_DISPATCH_FUNCS[__EGL_DISPATCH_COUNT + 1] = {\n"
for (func, eglFunc) in functions:
- text += generateGuardBegin(func, eglFunc)
if eglFunc["method"] != "none":
- text += " (__eglMustCastToProperFunctionPointerType) " +
eglFunc.get("prefix", "") + func.name + ",\n"
+ text += " (__eglMustCastToProperFunctionPointerType) dispatch_"
+ func.name + ",\n"
else:
text += " NULL, // " + func.name + "\n"
- text += generateGuardEnd(func, eglFunc)
text += " NULL\n"
text += "};\n"
return text
-def generateGuardBegin(func, eglFunc):
- ext = eglFunc.get("extension")
- if ext is not None:
- return "#if " + ext + "\n"
- else:
- return ""
-
-def generateGuardEnd(func, eglFunc):
- if eglFunc.get("extension") is not None:
- return "#endif\n"
- else:
- return ""
-
def generateDispatchFunc(func, eglFunc):
text = ""
- if eglFunc.get("static"):
- text += "static "
- elif eglFunc.get("public"):
- text += "PUBLIC "
+ text += "static "
text += textwrap.dedent(
r"""
- {f.rt} EGLAPIENTRY {ef[prefix]}{f.name}({f.decArgs})
+ {f.rt} EGLAPIENTRY dispatch_{f.name}({f.decArgs})
{{
typedef {f.rt} EGLAPIENTRY (* _pfn_{f.name})({f.decArgs});
- """).lstrip("\n").format(f=func, ef=eglFunc)
+ """).lstrip("\n").format(f=func)
if func.hasReturn():
text += " {f.rt} _ret = {ef[retval]};\n".format(f=func, ef=eglFunc)
--
Cheers,
Eric
_______________________________________________
mesa-dev mailing list
mesa-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/mesa-dev
