-for f in funcs:
- out.write("%s %s = 0;\n"%(f.typedef, f.name))
-
-out.write("\nExtension::SupportLevel init_%s()\n{\n"%target_ext.name.lower())
-if core_version:
- out.write("\tif(is_disabled(\"GL_%s\"))\n\t\treturn Extension::UNSUPPORTED;\n"%target_ext.name)
- out.write("#if !defined(__APPLE__) || defined(GL_VERSION_%d_%d)\n"%tuple(core_version))
- out.write("\tif(")
- if backport_ext:
- out.write("is_supported(\"GL_%s\") || "%backport_ext.name)
- out.write("is_supported(Version(%d, %d)"%tuple(core_version))
- if deprecated_version:
- out.write(", Version(%d, %d)"%tuple(deprecated_version))
- out.write("))\n\t{\n")
- for f in funcs:
- if target_api in f.supported_apis:
- gpa_suffix = ""
- if f.version is not None and f.version<=[1, 1]:
- gpa_suffix = "_1_1"
- out.write("\t\t%s = reinterpret_cast<%s>(GET_PROC_ADDRESS%s(%s));\n"%(f.name, f.typedef, gpa_suffix, f.name))
- out.write("\t\treturn Extension::CORE;\n")
- out.write("\t}\n")
- out.write("#endif\n")
-if source_ext and source_ext!=backport_ext:
- out.write("#if !defined(__APPLE__) || defined(GL_%s)\n"%target_ext.name)
- out.write("\tif(is_supported(\"GL_%s\"))\n\t{\n"%(source_ext.name))
- for f in funcs:
- if f.sources:
- src = None
- for s in f.sources:
- if s.name.endswith(source_ext.ext_type):
- src = s
- break
- if not src:
- src = f.sources[0]
+ def write_function_pointer_definitions(self, out):
+ for f in self.funcs:
+ out.write("{} {} = 0;\n".format(self.func_typedefs[f.name], f.name))
+
+ def write_init_function(self, out):
+ out.write("\nExtension::SupportLevel init_{}()\n{{\n".format(self.ext_name.lower()))
+ if self.core_version:
+ out.write("\tif(is_disabled(\"GL_{}\"))\n\t\treturn Extension::UNSUPPORTED;\n".format(self.ext_name))
+ out.write("#if !defined(__APPLE__) || defined({}_{})\n".format(self.api_prefix, self.core_version.as_define()))
+ out.write("\tif(")
+ if self.backport_ext:
+ out.write("is_supported(\"GL_{}\") || ".format(self.backport_ext.name))
+ out.write("is_supported({!r}".format(self.core_version))
+ if self.deprecated_version:
+ out.write(", {!r}".format(self.deprecated_version))
+ out.write("))\n\t{\n")
+ for f in self.funcs:
+ supp = f.api_support.get(self.host_api.name)
+ if supp:
+ gpa_suffix = ""
+ if supp.core_version is not None and supp.core_version<=Version(1, 1):
+ gpa_suffix = "_1_1"
+ out.write("\t\t{} = reinterpret_cast<{}>(GET_PROC_ADDRESS{}({}));\n".format(f.name, self.func_typedefs[f.name], gpa_suffix, f.name))
+ out.write("\t\treturn Extension::CORE;\n")
+ out.write("\t}\n")
+ out.write("#endif\n")
+ if self.source_exts:
+ out.write("#if !defined(__APPLE__) || defined(GL_{})\n".format(self.ext_name))
+ out.write("\tif(")
+ if self.base_version:
+ out.write("is_supported({!r}) && ".format(self.base_version))
+ out.write("{})\n\t{{\n".format(" && ".join("is_supported(\"GL_%s\")"%s.name for s in self.source_exts)))
+ for f in self.funcs:
+ supp = f.api_support.get(self.host_api.name)
+ src = None
+ for e in self.source_exts:
+ if f.name in e.things:
+ src = f
+ elif supp:
+ for s in supp.sources:
+ if s.name in e.things:
+ src = s
+ break
+ if src:
+ break
+ if not src and supp and supp.core_version and self.base_version>=supp.core_version:
+ sec = f
+
+ if src:
+ out.write("\t\t{} = reinterpret_cast<{}>(GET_PROC_ADDRESS({}));\n".format(f.name, self.func_typedefs[f.name], src.name))
+ out.write("\t\treturn Extension::EXTENSION;\n")
+ out.write("\t}\n")
+ out.write("#endif\n")
+ out.write("\treturn Extension::UNSUPPORTED;\n")
+ out.write("}\n")
+
+ def write_source_outro(self, out):
+ out.write("""
+} // namespace GL
+} // namespace Msp
+""")
+
+ def write_header(self, fn):
+ out = open(fn, "w")
+ self.write_header_intro(out)
+ self.write_enum_definitions(out)
+ self.write_function_pointer_declarations(out)
+ out.write("extern Extension {};\n".format(self.ext_name))
+ self.write_header_outro(out)
+
+ def write_source(self, fn):
+ out = open(fn, "w")
+ self.write_source_intro(out)
+ self.write_function_pointer_definitions(out)
+ self.write_init_function(out)
+ out.write("\nExtension {}(\"GL_{}\", init_{});\n".format(self.ext_name, self.ext_name, self.ext_name.lower()))
+ self.write_source_outro(out)
+
+
+def dump_api_support(supp, api, indent):
+ if supp.core_version:
+ print(indent+"core in version {}".format(supp.core_version))
+ if supp.deprecated_version:
+ print(indent+"deprecated in version {}".format(supp.deprecated_version))
+ for e in supp.extensions:
+ print(indent+"extension {} (preference {})".format(e.name, e.preference))
+ for r in supp.sources:
+ print(indent+"source {}".format(r.name))
+ dump_thing_info(r, api, indent+" ")
+
+def dump_thing_info(thing, api, indent):
+ for a in thing.aliases:
+ print(indent+"alias {}".format(a))
+ if api:
+ supp = thing.api_support.get(api)
+ dump_api_support(supp, api, indent)
+ else:
+ for a, s in thing.api_support.items():
+ print(indent+"api {}".format(a))
+ dump_api_support(s, a, indent+" ")
+
+
+class ExtensionParser:
+ def __init__(self, host_api):
+ self.host_api = host_api
+ self.target_ext = None
+ self.core_version = None
+ self.deprecated_version = None
+ self.backport_ext = None
+ self.source_exts = []
+ self.ignore_things = []
+ self.optional_things = []
+
+ def parse(self, fn):
+ for line in open(fn):
+ line = line.strip()
+ if not line or line.startswith("#"):
+ continue
+
+ parts = line.split()
+ api = None
+ keyword = parts[0]
+ if ":" in keyword:
+ api, keyword = keyword.split(":")
+
+ if api is not None and api!=self.host_api:
+ continue
+
+ if keyword=="extension":
+ self.target_ext = parts[1]
+ elif keyword=="core_version":
+ self.core_version = Version(*map(int, parts[1].split('.')))
+ elif keyword=="deprecated":
+ self.deprecated_version = Version(*map(int, parts[1].split('.')))
+ elif keyword=="backport":
+ self.backport_ext = parts[1]
+ elif keyword=="source":
+ self.source_exts.append(parts[1])
+ elif keyword=="ignore":
+ self.ignore_things.append(parts[1])
+ elif keyword=="optional":
+ self.optional_things.append(parts[1])
+ else:
+ print("Unknown keyword "+keyword)
+ return False
+
+ return True
+
+
+def get_extension(api_map, ext_name):
+ if "." in ext_name:
+ ext_api_name, ext_name = ext_name.split(".")
+ else:
+ ext_api_name = "gl"
+
+ return api_map[ext_api_name].extensions[ext_name]
+
+def resolve_things(api, things):
+ rthings = []
+ for t in things:
+ ct = [api.core_things[a] for a in t.aliases if a in api.core_things]
+ if ct:
+ rthings += ct