Skip to content

A
angle
Commit 7b7e5cad by Jamie Madill Committed by Commit Bot
Options

Clean up entry point generation script.

The main refactor from this change is to replace statements like this: decls, defs, export_defs, _, _, _, _ = get_entry_points( apis.EGL, eglxml.all_commands, egl_version_commands, False, egl_param_types, cmd_packed_egl_enums, EGL_PACKED_TYPES, egl_ep_to_object, TEMPLATE_EGL_ENTRY_POINT_EXPORT) With statements like this: eps = EGLEntryPoints(eglxml, egl_version_commands) This will make the script easier to maintain and extend. Bug: angleproject:5653 Change-Id: Ibd0930d45b8629702b7782f43a2d7ebfa4dac9b8 Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2705156Reviewed-by: 's avatarGeoff Lang <geofflang@chromium.org> Reviewed-by: 's avatarCody Northrop <cnorthrop@google.com> Commit-Queue: Jamie Madill <jmadill@chromium.org>
parent f19f319a
Showing with 216 additions and 182 deletions
scripts/code_generation_hashes/GL_EGL_WGL_loader.json
......@@ -10,7 +10,7 @@
"scripts/gl_angle_ext.xml":
"0b4f3476d76a5ccc40af342d6c08739d",
"scripts/registry_xml.py":
"c85875a215dcf74e2ed363684f18c26c",
"574c34b93db348eb2e13d8026c3014ff",
"scripts/wgl.xml":
"c36001431919e1c435f1215a85f7e1db",
"src/libEGL/egl_loader_autogen.cpp":
......
scripts/code_generation_hashes/GL_EGL_entry_points.json
......@@ -8,13 +8,13 @@
"scripts/entry_point_packed_gl_enums.json":
"4f7b43863a5e61991bba4010db463679",
"scripts/generate_entry_points.py":
"195ba6eaeb6dcf6596720976f73755a5",
"09729fe8be0f242cc97058c2b5ab7310",
"scripts/gl.xml":
"f66967f3f3d696b5d8306fd80bbd49a8",
"scripts/gl_angle_ext.xml":
"0b4f3476d76a5ccc40af342d6c08739d",
"scripts/registry_xml.py":
"c85875a215dcf74e2ed363684f18c26c",
"574c34b93db348eb2e13d8026c3014ff",
"scripts/wgl.xml":
"c36001431919e1c435f1215a85f7e1db",
"src/common/entry_points_enum_autogen.cpp":
......
scripts/code_generation_hashes/GLenum_value_to_string_map.json
......@@ -6,7 +6,7 @@
"scripts/gl_angle_ext.xml":
"0b4f3476d76a5ccc40af342d6c08739d",
"scripts/registry_xml.py":
"c85875a215dcf74e2ed363684f18c26c",
"574c34b93db348eb2e13d8026c3014ff",
"src/libANGLE/capture/gl_enum_utils_autogen.cpp":
"ab1a59ecc7d292db6cc2840280f86a59",
"src/libANGLE/capture/gl_enum_utils_autogen.h":
......
scripts/code_generation_hashes/proc_table.json
......@@ -10,7 +10,7 @@
"scripts/gl_angle_ext.xml":
"0b4f3476d76a5ccc40af342d6c08739d",
"scripts/registry_xml.py":
"c85875a215dcf74e2ed363684f18c26c",
"574c34b93db348eb2e13d8026c3014ff",
"scripts/wgl.xml":
"c36001431919e1c435f1215a85f7e1db",
"src/libGL/proc_table_wgl_autogen.cpp":
......
scripts/generate_entry_points.py
......@@ -10,7 +10,7 @@
import sys, os, pprint, json
import registry_xml
from registry_xml import apis
from registry_xml import apis, script_relative, strip_api_prefix
# Paths
EGL_GET_LABELED_OBJECT_DATA_PATH = "../src/libGLESv2/egl_get_labeled_object_data.json"
......@@ -1012,14 +1012,6 @@ def is_aliasing_excepted(api, cmd_name):
return api == apis.GLES and cmd_name in ALIASING_EXCEPTIONS
def script_relative(path):
return os.path.join(os.path.dirname(sys.argv[0]), path)
def strip_api_prefix(cmd_name):
return cmd_name.lstrip("wegl")
def format_entry_point_decl(api, cmd_name, proto, params, is_explicit_context):
comma_if_needed = ", " if len(params) > 0 else ""
stripped = strip_api_prefix(cmd_name)
......@@ -1211,7 +1203,7 @@ def get_def_template(api, return_type):
def format_entry_point_def(api, command_node, cmd_name, proto, params, is_explicit_context,
cmd_packed_enums, packed_param_types, egl_ep_to_object):
cmd_packed_enums, packed_param_types, ep_to_object):
packed_enums = get_packed_enums(api, cmd_packed_enums, cmd_name, packed_param_types, params)
internal_params = [just_the_name_packed(param, packed_enums) for param in params]
packed_gl_enum_conversions = []
......@@ -1270,7 +1262,7 @@ def format_entry_point_def(api, command_node, cmd_name, proto, params, is_explic
"assert_explicit_context":
"\nASSERT(context == GetValidGlobalContext());" if is_explicit_context else "",
"labeled_object":
get_egl_entry_point_labeled_object(egl_ep_to_object, cmd_name, params, packed_enums)
get_egl_entry_point_labeled_object(ep_to_object, cmd_name, params, packed_enums)
}
template = get_def_template(api, return_type)
......@@ -1446,50 +1438,124 @@ def path_to(folder, file):
return os.path.join(script_relative(".."), "src", folder, file)
def get_entry_points(api, all_commands, commands, is_explicit_context, all_param_types,
cmd_packed_gl_enums, packed_param_types, egl_ep_to_object, export_template):
decls = []
defs = []
export_defs = []
validation_protos = []
capture_protos = []
capture_methods = []
capture_pointer_funcs = []
for command in all_commands:
proto = command.find('proto')
cmd_name = proto.find('name').text
if api == apis.WGL:
cmd_name = cmd_name if cmd_name[:3] == 'wgl' else 'wgl' + cmd_name
if cmd_name not in commands:
continue
param_text = ["".join(param.itertext()) for param in command.findall('param')]
proto_text = "".join(proto.itertext())
decls.append(
format_entry_point_decl(api, cmd_name, proto_text, param_text, is_explicit_context))
defs.append(
format_entry_point_def(api, command, cmd_name, proto_text, param_text,
is_explicit_context, cmd_packed_gl_enums, packed_param_types,
egl_ep_to_object))
export_defs.append(
format_entry_point_export(cmd_name, proto_text, param_text, is_explicit_context,
export_template))
validation_protos.append(
format_validation_proto(api, cmd_name, param_text, cmd_packed_gl_enums,
packed_param_types))
capture_protos.append(
format_capture_proto(api, cmd_name, proto_text, param_text, cmd_packed_gl_enums,
packed_param_types))
capture_methods.append(
format_capture_method(api, command, cmd_name, proto_text, param_text, all_param_types,
capture_pointer_funcs, cmd_packed_gl_enums, packed_param_types))
return decls, defs, export_defs, validation_protos, capture_protos, capture_methods, capture_pointer_funcs
class ANGLEEntryPoints(registry_xml.EntryPoints):
def __init__(self,
api,
xml,
commands,
all_param_types,
cmd_packed_enums,
export_template=TEMPLATE_GL_ENTRY_POINT_EXPORT,
is_explicit_context=False,
packed_param_types=[],
ep_to_object={}):
super().__init__(api, xml, commands)
self.decls = []
self.defs = []
self.export_defs = []
self.validation_protos = []
self.capture_protos = []
self.capture_methods = []
self.capture_pointer_funcs = []
for (cmd_name, command_node, param_text, proto_text) in self.get_infos():
self.decls.append(
format_entry_point_decl(self.api, cmd_name, proto_text, param_text,
is_explicit_context))
self.defs.append(
format_entry_point_def(self.api, command_node, cmd_name, proto_text, param_text,
is_explicit_context, cmd_packed_enums, packed_param_types,
ep_to_object))
self.export_defs.append(
format_entry_point_export(cmd_name, proto_text, param_text, is_explicit_context,
export_template))
self.validation_protos.append(
format_validation_proto(self.api, cmd_name, param_text, cmd_packed_enums,
packed_param_types))
self.capture_protos.append(
format_capture_proto(self.api, cmd_name, proto_text, param_text, cmd_packed_enums,
packed_param_types))
self.capture_methods.append(
format_capture_method(self.api, command_node, cmd_name, proto_text, param_text,
all_param_types, self.capture_pointer_funcs,
cmd_packed_enums, packed_param_types))
class GLEntryPoints(ANGLEEntryPoints):
all_param_types = set()
def __init__(self, api, xml, commands, is_explicit_context=False):
super().__init__(
api,
xml,
commands,
GLEntryPoints.all_param_types,
GLEntryPoints.get_packed_enums(),
is_explicit_context=is_explicit_context)
_packed_enums = None
@classmethod
def get_packed_enums(cls):
if not cls._packed_enums:
with open(script_relative('entry_point_packed_gl_enums.json')) as f:
cls._packed_enums = json.loads(f.read())
return cls._packed_enums
class EGLEntryPoints(ANGLEEntryPoints):
all_param_types = set()
def __init__(self, xml, commands):
super().__init__(
apis.EGL,
xml,
commands,
EGLEntryPoints.all_param_types,
EGLEntryPoints.get_packed_enums(),
export_template=TEMPLATE_EGL_ENTRY_POINT_EXPORT,
packed_param_types=EGL_PACKED_TYPES,
ep_to_object=EGLEntryPoints._get_ep_to_object())
_ep_to_object = None
@classmethod
def _get_ep_to_object(cls):
if cls._ep_to_object:
return cls._ep_to_object
with open(EGL_GET_LABELED_OBJECT_DATA_PATH) as f:
try:
spec_json = json.loads(f.read())
except ValueError:
raise Exception("Could not decode JSON from %s" % EGL_GET_LABELED_OBJECT_DATA_PATH)
# Construct a mapping from EP to type. Fill in the gaps with Display/None.
cls._ep_to_object = {}
for category, eps in spec_json.items():
if category == 'description':
continue
for ep in eps:
cls._ep_to_object[ep] = category
return cls._ep_to_object
_packed_enums = None
@classmethod
def get_packed_enums(cls):
if not cls._packed_enums:
with open(script_relative('entry_point_packed_egl_enums.json')) as f:
cls._packed_enums = json.loads(f.read())
return cls._packed_enums
def get_decls(api,
......@@ -2038,25 +2104,6 @@ def get_egl_exports():
return exports
def get_egl_object_category_map():
with open(EGL_GET_LABELED_OBJECT_DATA_PATH) as f:
try:
spec_json = json.loads(f.read())
except ValueError:
raise Exception("Could not decode JSON from %s" % EGL_GET_LABELED_OBJECT_DATA_PATH)
# Construct a mapping from EP to type. Fill in the gaps with Display/None.
ep_to_object = {}
for category, eps in spec_json.items():
if category == 'description':
continue
for ep in eps:
ep_to_object[ep] = category
return ep_to_object
# Construct a mapping from an EGL EP to object function
def get_egl_entry_point_labeled_object(ep_to_object, cmd_stripped, params, packed_enums):
......@@ -2226,9 +2273,6 @@ def main():
return 1
return 0
with open(script_relative('entry_point_packed_gl_enums.json')) as f:
cmd_packed_gl_enums = json.loads(f.read())
glesdecls = {}
glesdecls['core'] = {}
glesdecls['exts'] = {}
......@@ -2245,7 +2289,6 @@ def main():
# Stores core commands to keep track of duplicates
all_commands_no_suffix = []
all_commands_with_suffix = []
all_gles_param_types = set()
# First run through the main GLES entry points. Since ES2+ is the primary use
# case, we go through those first and then add ES1-only APIs at the end.
......@@ -2262,20 +2305,17 @@ def main():
xml.AddCommands(feature_name, version)
gles_commands = xml.commands[version]
version_commands = xml.commands[version]
all_commands_no_suffix.extend(xml.commands[version])
all_commands_with_suffix.extend(xml.commands[version])
decls, defs, libgles_defs, validation_protos, capture_protos, capture_methods, capture_pointer_funcs = get_entry_points(
apis.GLES, xml.all_commands, gles_commands, False, all_gles_param_types,
cmd_packed_gl_enums, [], {}, TEMPLATE_GL_ENTRY_POINT_EXPORT)
eps = GLEntryPoints(apis.GLES, xml, version_commands)
# Write the version as a comment before the first EP.
libgles_defs.insert(0, "\n// OpenGL ES %s" % comment)
libgles_ep_exports.append("\n ; OpenGL ES %s" % comment)
libgles_ep_defs += libgles_defs
libgles_ep_exports += get_exports(gles_commands)
libgles_ep_defs += ["\n// OpenGL ES %s" % comment] + eps.export_defs
libgles_ep_exports += get_exports(version_commands)
major_if_not_one = major_version if major_version != 1 else ""
minor_if_not_zero = minor_version if minor_version != 0 else ""
......@@ -2291,22 +2331,22 @@ def main():
source_includes = TEMPLATE_SOURCES_INCLUDES.format(
header_version=annotation.lower(), validation_header_version="ES" + version_annotation)
write_file(annotation, "GLES " + comment, TEMPLATE_ENTRY_POINT_HEADER, "\n".join(decls),
"h", header_includes, "libGLESv2", "gl.xml")
write_file(annotation, "GLES " + comment, TEMPLATE_ENTRY_POINT_SOURCE, "\n".join(defs),
write_file(annotation, "GLES " + comment, TEMPLATE_ENTRY_POINT_HEADER,
"\n".join(eps.decls), "h", header_includes, "libGLESv2", "gl.xml")
write_file(annotation, "GLES " + comment, TEMPLATE_ENTRY_POINT_SOURCE, "\n".join(eps.defs),
"cpp", source_includes, "libGLESv2", "gl.xml")
glesdecls['core'][(major_version,
minor_version)] = get_decls(apis.GLES, CONTEXT_DECL_FORMAT,
xml.all_commands, gles_commands, [],
cmd_packed_gl_enums)
xml.all_commands, version_commands, [],
GLEntryPoints.get_packed_enums())
validation_annotation = "ES%s%s" % (major_version, minor_if_not_zero)
write_gl_validation_header(validation_annotation, "ES %s" % comment, validation_protos,
write_gl_validation_header(validation_annotation, "ES %s" % comment, eps.validation_protos,
"gl.xml and gl_angle_ext.xml")
write_capture_header(version, comment, capture_protos, capture_pointer_funcs)
write_capture_source(version, validation_annotation, comment, capture_methods)
write_capture_header(version, comment, eps.capture_protos, eps.capture_pointer_funcs)
write_capture_source(version, validation_annotation, comment, eps.capture_methods)
# After we finish with the main entry points, we process the extensions.
extension_defs = []
......@@ -2317,7 +2357,7 @@ def main():
ext_validation_protos = []
ext_capture_protos = []
ext_capture_methods = []
ext_capture_param_funcs = []
ext_capture_pointer_funcs = []
for gles1ext in registry_xml.gles1_extensions:
glesdecls['exts']['GLES1 Extensions'][gles1ext] = []
......@@ -2332,46 +2372,41 @@ def main():
extension_commands.extend(xml.ext_data[extension_name])
# Detect and filter duplicate extensions.
decls, defs, libgles_defs, validation_protos, capture_protos, capture_methods, capture_param_funcs = get_entry_points(
apis.GLES, xml.all_commands, ext_cmd_names, False, all_gles_param_types,
cmd_packed_gl_enums, [], {}, TEMPLATE_GL_ENTRY_POINT_EXPORT)
# Avoid writing out entry points defined by a prior extension.
for dupe in xml.ext_dupes[extension_name]:
msg = "// {} is already defined.\n".format(strip_api_prefix(dupe))
defs.append(msg)
eps = GLEntryPoints(apis.GLES, xml, ext_cmd_names)
# Write the extension name as a comment before the first EP.
comment = "\n// {}".format(extension_name)
defs.insert(0, comment)
decls.insert(0, comment)
libgles_defs.insert(0, comment)
libgles_ep_exports.append("\n ; %s" % extension_name)
extension_defs += defs
extension_decls += decls
extension_defs += [comment] + eps.defs
extension_decls += [comment] + eps.decls
# Avoid writing out entry points defined by a prior extension.
for dupe in xml.ext_dupes[extension_name]:
msg = "// {} is already defined.\n".format(strip_api_prefix(dupe))
extension_defs.append(msg)
ext_validation_protos += [comment] + validation_protos
ext_capture_protos += [comment] + capture_protos
ext_capture_methods += capture_methods
ext_capture_param_funcs += capture_param_funcs
ext_validation_protos += [comment] + eps.validation_protos
ext_capture_protos += [comment] + eps.capture_protos
ext_capture_methods += eps.capture_methods
ext_capture_pointer_funcs += eps.capture_pointer_funcs
libgles_ep_defs += libgles_defs
libgles_ep_defs += [comment] + eps.export_defs
libgles_ep_exports += get_exports(ext_cmd_names)
if (extension_name in registry_xml.gles1_extensions and
extension_name not in GLES1_NO_CONTEXT_DECL_EXTENSIONS):
glesdecls['exts']['GLES1 Extensions'][extension_name] = get_decls(
apis.GLES, CONTEXT_DECL_FORMAT, xml.all_commands, ext_cmd_names,
all_commands_no_suffix, cmd_packed_gl_enums)
all_commands_no_suffix, GLEntryPoints.get_packed_enums())
if extension_name in registry_xml.gles_extensions:
glesdecls['exts']['GLES2+ Extensions'][extension_name] = get_decls(
apis.GLES, CONTEXT_DECL_FORMAT, xml.all_commands, ext_cmd_names,
all_commands_no_suffix, cmd_packed_gl_enums)
all_commands_no_suffix, GLEntryPoints.get_packed_enums())
if extension_name in registry_xml.angle_extensions:
glesdecls['exts']['ANGLE Extensions'][extension_name] = get_decls(
apis.GLES, CONTEXT_DECL_FORMAT, xml.all_commands, ext_cmd_names,
all_commands_no_suffix, cmd_packed_gl_enums)
all_commands_no_suffix, GLEntryPoints.get_packed_enums())
for name in extension_commands:
all_commands_with_suffix.append(name)
......@@ -2387,14 +2422,12 @@ def main():
cmds = xml.all_cmd_names.get_all_commands()
# Get the explicit context entry points
decls, defs, libgles_defs, validation_protos, capture_protos, capture_methods, capture_param_funcs = get_entry_points(
apis.GLES, xml.all_commands, cmds, True, all_gles_param_types, cmd_packed_gl_enums, [],
{}, TEMPLATE_GL_ENTRY_POINT_EXPORT)
eps = GLEntryPoints(apis.GLES, xml, cmds, is_explicit_context=True)
# Append the explicit context entry points
extension_decls += decls
extension_defs += defs
libgles_ep_defs += libgles_defs
extension_decls += eps.decls
extension_defs += eps.defs
libgles_ep_defs += eps.export_defs
libgles_ep_exports.append("\n ; EGL_ANGLE_explicit_context")
libgles_ep_exports += get_exports(cmds, lambda x: "%sContextANGLE" % x)
......@@ -2467,29 +2500,24 @@ def main():
]
# Validation duplicates handled with suffix
_, _, _, protos, _, _, _ = get_entry_points(apis.GL, glxml.all_commands,
just_libgl_commands_suffix, False,
all_gles_param_types, cmd_packed_gl_enums,
[], {}, TEMPLATE_GL_ENTRY_POINT_EXPORT)
decls, defs, libgl_defs, _, _, _, _ = get_entry_points(apis.GL, glxml.all_commands,
all_libgl_commands, False,
all_gles_param_types,
cmd_packed_gl_enums, [], {},
TEMPLATE_GL_ENTRY_POINT_EXPORT)
desktop_gl_decls['core'][(major_version, "X")] += get_decls(
apis.GL, CONTEXT_DECL_FORMAT, glxml.all_commands, just_libgl_commands,
all_commands_no_suffix, cmd_packed_gl_enums)
eps_suffix = GLEntryPoints(apis.GL, glxml, just_libgl_commands_suffix)
eps = GLEntryPoints(apis.GL, glxml, all_libgl_commands)
desktop_gl_decls['core'][(major_version,
"X")] += get_decls(apis.GL, CONTEXT_DECL_FORMAT,
glxml.all_commands, just_libgl_commands,
all_commands_no_suffix,
GLEntryPoints.get_packed_enums())
# Write the version as a comment before the first EP.
cpp_comment = "\n// GL %s" % comment
def_comment = "\n ; GL %s" % comment
libgl_ep_defs += [cpp_comment] + libgl_defs
libgl_ep_defs += [cpp_comment] + eps.export_defs
libgl_ep_exports += [def_comment] + get_exports(all_libgl_commands)
validation_protos += [cpp_comment] + protos
ver_decls += [cpp_comment] + decls
ver_defs += [cpp_comment] + defs
validation_protos += [cpp_comment] + eps_suffix.validation_protos
ver_decls += [cpp_comment] + eps.decls
ver_defs += [cpp_comment] + eps.defs
annotation = "GL_%d" % major_version
name = "Desktop GL %s.x" % major_version
......@@ -2508,17 +2536,12 @@ def main():
# EGL
eglxml = registry_xml.RegistryXML('egl.xml', 'egl_angle_ext.xml')
egl_param_types = set()
with open(script_relative('entry_point_packed_egl_enums.json')) as f:
cmd_packed_egl_enums = json.loads(f.read())
egl_validation_protos = []
egl_decls = []
egl_defs = []
libegl_ep_defs = []
libegl_windows_def_exports = []
egl_ep_to_object = get_egl_object_category_map()
egl_commands = []
for major_version, minor_version in registry_xml.EGL_VERSIONS:
......@@ -2538,18 +2561,15 @@ def main():
if not egl_version_commands:
continue
decls, defs, export_defs, validation_protos, _, _, _ = get_entry_points(
apis.EGL, eglxml.all_commands, egl_version_commands, False, egl_param_types,
cmd_packed_egl_enums, EGL_PACKED_TYPES, egl_ep_to_object,
TEMPLATE_EGL_ENTRY_POINT_EXPORT)
eps = EGLEntryPoints(eglxml, egl_version_commands)
comment = "\n// EGL %d.%d" % (major_version, minor_version)
win_def_comment = "\n ; EGL %d.%d" % (major_version, minor_version)
egl_validation_protos += [comment] + validation_protos
egl_decls += [comment] + decls
egl_defs += [comment] + defs
libegl_ep_defs += [comment] + export_defs
egl_decls += [comment] + eps.decls
egl_defs += [comment] + eps.defs
libegl_ep_defs += [comment] + eps.export_defs
egl_validation_protos += [comment] + eps.validation_protos
libegl_windows_def_exports += [win_def_comment] + get_exports(eglxml.commands[version])
write_file("egl", "EGL", TEMPLATE_ENTRY_POINT_HEADER, "\n".join(egl_decls), "h",
......@@ -2557,7 +2577,7 @@ def main():
write_file("egl", "EGL", TEMPLATE_ENTRY_POINT_SOURCE, "\n".join(egl_defs), "cpp",
EGL_SOURCE_INCLUDES, "libGLESv2", "egl.xml")
write_egl_stubs_header("egl", "EGL", "egl.xml", EGL_STUBS_HEADER_PATH, eglxml.all_commands,
egl_commands, cmd_packed_egl_enums)
egl_commands, EGLEntryPoints.get_packed_enums())
eglxml.AddExtensionCommands(registry_xml.supported_egl_extensions, ['egl'])
egl_ext_decls = []
......@@ -2571,27 +2591,24 @@ def main():
continue
# Detect and filter duplicate extensions.
decls, defs, export_defs, validation_protos, _, _, _ = get_entry_points(
apis.EGL, eglxml.all_commands, ext_cmd_names, False, egl_param_types,
cmd_packed_egl_enums, EGL_PACKED_TYPES, egl_ep_to_object,
TEMPLATE_EGL_ENTRY_POINT_EXPORT)
# Avoid writing out entry points defined by a prior extension.
for dupe in eglxml.ext_dupes[extension_name]:
msg = "// %s is already defined.\n" % strip_api_prefix(dupe)
defs.append(msg)
eps = EGLEntryPoints(eglxml, ext_cmd_names)
comment = "\n// %s" % extension_name
win_def_comment = "\n ; %s" % (extension_name)
egl_ext_commands += ext_cmd_names
egl_validation_protos += [comment] + validation_protos
egl_ext_decls += [comment] + decls
egl_ext_defs += [comment] + defs
libegl_ep_defs += [comment] + export_defs
egl_ext_decls += [comment] + eps.decls
egl_ext_defs += [comment] + eps.defs
libegl_ep_defs += [comment] + eps.export_defs
egl_validation_protos += [comment] + eps.validation_protos
libegl_windows_def_exports += [win_def_comment] + get_exports(ext_cmd_names)
# Avoid writing out entry points defined by a prior extension.
for dupe in eglxml.ext_dupes[extension_name]:
msg = "// %s is already defined.\n" % strip_api_prefix(dupe)
egl_ext_defs.append(msg)
write_file("egl_ext", "EGL Extension", TEMPLATE_ENTRY_POINT_HEADER, "\n".join(egl_ext_decls),
"h", EGL_EXT_HEADER_INCLUDES, "libGLESv2", "egl.xml and egl_angle_ext.xml")
write_file("egl_ext", "EGL Extension", TEMPLATE_ENTRY_POINT_SOURCE, "\n".join(egl_ext_defs),
......@@ -2600,7 +2617,7 @@ def main():
TEMPLATE_EGL_VALIDATION_HEADER)
write_egl_stubs_header("egl_ext", "EXT extension", "egl.xml and egl_angle_ext.xml",
EGL_EXT_STUBS_HEADER_PATH, eglxml.all_commands, egl_ext_commands,
cmd_packed_egl_enums)
EGLEntryPoints.get_packed_enums())
# WGL
wglxml = registry_xml.RegistryXML('wgl.xml')
......@@ -2614,11 +2631,6 @@ def main():
wgl_commands = [cmd if cmd[:3] == 'wgl' else 'wgl' + cmd for cmd in wgl_commands]
wgl_param_types = set()
decls_wgl, defs_wgl, wgl_defs, validation_protos_wgl, _, _, _ = get_entry_points(
apis.WGL, wglxml.all_commands, wgl_commands, False, wgl_param_types, {}, [], {},
TEMPLATE_GL_ENTRY_POINT_EXPORT)
# Write the version as a comment before the first EP.
libgl_ep_exports.append("\n ; WGL %s" % comment)
......@@ -2637,7 +2649,7 @@ def main():
write_gl_validation_header("ESEXT", "ES extension", ext_validation_protos,
"gl.xml and gl_angle_ext.xml")
write_capture_header("ext", "extension", ext_capture_protos, ext_capture_param_funcs)
write_capture_header("ext", "extension", ext_capture_protos, ext_capture_pointer_funcs)
write_capture_source("ext", "ESEXT", "extension", ext_capture_methods)
write_context_api_decls(glesdecls, "gles")
......@@ -2697,11 +2709,11 @@ def main():
write_windows_def_file("egl.xml and egl_angle_ext.xml", "libEGL", "libEGL", "libEGL",
libegl_windows_def_exports)
all_gles_param_types = sorted(all_gles_param_types)
all_gles_param_types = sorted(GLEntryPoints.all_param_types)
write_capture_helper_header(all_gles_param_types)
write_capture_helper_source(all_gles_param_types)
write_capture_replay_source(apis.GLES, xml.all_commands, all_commands_no_suffix,
cmd_packed_gl_enums, [])
GLEntryPoints.get_packed_enums(), [])
if __name__ == '__main__':
......
scripts/registry_xml.py
......@@ -238,6 +238,10 @@ def path_to(folder, file):
return os.path.join(script_relative(".."), "src", folder, file)
def strip_api_prefix(cmd_name):
return cmd_name.lstrip("wegl")
class CommandNames:
def __init__(self):
......@@ -365,6 +369,24 @@ class RegistryXML:
class EntryPoints:
def __init__(self, api, xml):
for command in xml.all_commands:
pass
def __init__(self, api, xml, commands):
self.api = api
self._cmd_info = []
for command_node in xml.all_commands:
proto = command_node.find('proto')
cmd_name = proto.find('name').text
if api == apis.WGL:
cmd_name = cmd_name if cmd_name[:3] == 'wgl' else 'wgl' + cmd_name
if cmd_name not in commands:
continue
param_text = ["".join(param.itertext()) for param in command_node.findall('param')]
proto_text = "".join(proto.itertext())
self._cmd_info.append((cmd_name, command_node, param_text, proto_text))
def get_infos(self):
return self._cmd_info
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment