scripts/extgen.py

   1 #!/usr/bin/python
   2
   3 import sys
   4 import os
   5 import xml.dom
   6 import xml.dom.minidom
   7 import itertools
   8 import re
   9
  10 class Version:
  11         def __init__(self, *args):
  12                 if len(args)==0:
  13                         self.major = 0
  14                         self.minor = 0
  15                 elif len(args)==2:
  16                         self.major = args[0]
  17                         self.minor = args[1]
  18                 else:
  19                         raise TypeError, "__init__() takes zero or two arguments (%d given)"%len(args)
  20
  21         def __str__(self):
  22                 return "%d.%d"%(self.major, self.minor)
  23
  24         def __repr__(self):
  25                 return "Version(%d, %d)"%(self.major, self.minor)
  26
  27         def as_define(self):
  28                 return "VERSION_%d_%d"%(self.major, self.minor)
  29
  30         def __lt__(self, other):
  31                 if other is None:
  32                         return False
  33
  34                 if self.major!=other.major:
  35                         return self.major<other.major
  36                 return self.minor<other.minor
  37
  38         def __gt__(self, other):
  39                 if other is None:
  40                         return True
  41
  42                 if self.major!=other.major:
  43                         return self.major>other.major
  44                 return self.minor>other.minor
  45
  46         def __eq__(self, other):
  47                 if other is None:
  48                         return False
  49
  50                 return (self.major==other.major and self.minor==other.minor)
  51
  52
  53 class Thing:
  54         FUNCTION = 1
  55         ENUM = 2
  56
  57         class ApiSupport:
  58                 def __init__(self):
  59                         self.core_version = None
  60                         self.deprecated_version = None
  61                         self.extensions = []
  62                         self.sources = []
  63
  64         def __init__(self, name, kind):
  65                 self.name = name
  66                 self.kind = kind
  67                 self.aliases = []
  68                 self.api_support = {}
  69
  70         def get_or_create_api_support(self, api):
  71                 supp = self.api_support.get(api)
  72                 if not supp:
  73                         supp = Thing.ApiSupport()
  74                         self.api_support[api] = supp
  75                 return supp
  76
  77
  78 class Function(Thing):
  79         def __init__(self, name):
  80                 Thing.__init__(self, name, Thing.FUNCTION)
  81                 self.return_type = "void"
  82                 self.params = []
  83
  84
  85 r_bitmask = re.compile("_BIT[0-9]*(_|$)")
  86
  87 class Enum(Thing):
  88         def __init__(self, name):
  89                 Thing.__init__(self, name, Thing.ENUM)
  90                 self.value = 0
  91                 self.bitmask = bool(r_bitmask.search(self.name))
  92
  93
  94 class Extension:
  95         def __init__(self, name, api):
  96                 self.name = name
  97                 underscore = name.find('_')
  98                 self.ext_type = name[0:underscore]
  99                 self.base_name = name[underscore+1:]
 100                 self.api = api
 101                 self.things = {}
 102                 self.preference = 0
 103                 if self.ext_type=="EXT":
 104                         self.preference = 1
 105                 elif self.ext_type=="ARB" or self.ext_type=="OES":
 106                         self.preference = 2
 107                 self.backport = False
 108
 109
 110 class Api:
 111         def __init__(self, name):
 112                 self.name = name
 113                 self.latest_version = None
 114                 self.core_things = {}
 115                 self.extensions = {}
 116
 117
 118 def get_nested_elements(elem, path):
 119         childElements = [c for c in elem.childNodes if c.nodeType==xml.dom.Node.ELEMENT_NODE]
 120         if '/' in path:
 121                 head, tail = path.split('/', 1)
 122                 result = []
 123                 for c in childElements:
 124                         if c.tagName==head:
 125                                 result += get_nested_elements(c, tail)
 126                 return result
 127         else:
 128                 return [c for c in childElements if c.tagName==path]
 129
 130 def get_first_child(elem, tag):
 131         for c in elem.childNodes:
 132                 if c.nodeType==xml.dom.Node.ELEMENT_NODE and c.tagName==tag:
 133                         return c
 134         return None
 135
 136 def get_text_contents(node):
 137         result = ""
 138         for c in node.childNodes:
 139                 if c.nodeType==xml.dom.Node.TEXT_NODE or c.nodeType==xml.dom.Node.CDATA_SECTION_NODE:
 140                         result += c.data
 141                 else:
 142                         result += get_text_contents(c)
 143         return result
 144
 145 def get_or_create(map, name, type, *args):
 146         obj = map.get(name)
 147         if not obj:
 148                 obj = type(name, *args)
 149                 map[name] = obj
 150         return obj
 151
 152
 153 class GlXmlParser:
 154         def __init__(self):
 155                 self.apis = {}
 156                 self.things = {}
 157
 158         def parse_command(self, cmd):
 159                 proto = get_first_child(cmd, "proto")
 160                 name = get_text_contents(get_first_child(proto, "name"))
 161                 func = get_or_create(self.things, name, Function)
 162
 163                 aliases = get_nested_elements(cmd, "alias")
 164                 func.aliases = [a.getAttribute("name") for a in aliases]
 165
 166                 ptype = get_first_child(proto, "ptype")
 167                 if ptype:
 168                         func.return_type = get_text_contents(ptype)
 169                 else:
 170                         for c in proto.childNodes:
 171                                 if c.nodeType==xml.dom.Node.TEXT_NODE and c.data.strip():
 172                                         func.return_type = c.data.strip()
 173                                         break
 174
 175                 params = get_nested_elements(cmd, "param")
 176                 func.params = map(get_text_contents, params)
 177
 178         def parse_enum(self, en):
 179                 name = en.getAttribute("name")
 180                 enum = get_or_create(self.things, name, Enum)
 181
 182                 enum.value = int(en.getAttribute("value"), 16)
 183
 184                 alias = en.getAttribute("alias")
 185                 if alias:
 186                         enum.aliases.append(alias)
 187
 188         def parse_feature(self, feat):
 189                 api_name = feat.getAttribute("api")
 190                 api = get_or_create(self.apis, api_name, Api)
 191
 192                 version = feat.getAttribute("number")
 193                 if version:
 194                         version = Version(*map(int, version.split('.')))
 195                 else:
 196                         version = None
 197
 198                 requires = get_nested_elements(feat, "require")
 199                 for req in requires:
 200                         commands = get_nested_elements(req, "command")
 201                         enums = get_nested_elements(req, "enum")
 202                         for t in itertools.chain(commands, enums):
 203                                 name = t.getAttribute("name")
 204                                 thing = self.things.get(name)
 205                                 if thing:
 206                                         supp = thing.get_or_create_api_support(api.name)
 207                                         if not supp.core_version or version<supp.core_version:
 208                                                 supp.core_version = version
 209                                         api.core_things[thing.name] = thing
 210
 211                 removes = get_nested_elements(feat, "remove")
 212                 for rem in removes:
 213                         commands = get_nested_elements(rem, "command")
 214                         enums = get_nested_elements(rem, "enum")
 215
 216                         for t in itertools.chain(commands, enums):
 217                                 name = t.getAttribute("name")
 218                                 thing = self.things.get(name)
 219                                 if thing:
 220                                         supp = thing.get_or_create_api_support(api.name)
 221                                         supp.deprecated_version = version
 222
 223         def parse_extension(self, ext):
 224                 ext_things_by_api = {}
 225                 requires = get_nested_elements(ext, "require")
 226                 for req in requires:
 227                         api = req.getAttribute("api")
 228                         ext_things = ext_things_by_api.setdefault(api, [])
 229
 230                         commands = get_nested_elements(req, "command")
 231                         enums = get_nested_elements(req, "enum")
 232                         for t in itertools.chain(commands, enums):
 233                                 name = t.getAttribute("name")
 234                                 thing = self.things.get(name)
 235                                 if thing:
 236                                         ext_things.append(thing)
 237
 238                 ext_name = ext.getAttribute("name")
 239                 if ext_name.startswith("GL_"):
 240                         ext_name = ext_name[3:]
 241
 242                 common_things = ext_things_by_api.get("", [])
 243                 supported = ext.getAttribute("supported").split('|')
 244                 for s in supported:
 245                         api = self.apis.get(s)
 246                         if not api:
 247                                 continue
 248
 249                         ext = get_or_create(api.extensions, ext_name, Extension, api)
 250                         api_things = ext_things_by_api.get(s, [])
 251                         for t in itertools.chain(common_things, api_things):
 252                                 ext.things[t.name] = t
 253                                 t.get_or_create_api_support(api.name).extensions.append(ext)
 254
 255         def parse_file(self, fn):
 256                 doc = xml.dom.minidom.parse(fn)
 257                 root = doc.documentElement
 258
 259                 commands = get_nested_elements(root, "commands/command")
 260                 for cmd in commands:
 261                         self.parse_command(cmd)
 262
 263                 enums = get_nested_elements(root, "enums/enum")
 264                 for en in enums:
 265                         self.parse_enum(en)
 266
 267                 features = get_nested_elements(root, "feature")
 268                 for feat in features:
 269                         self.parse_feature(feat)
 270
 271                 extensions = get_nested_elements(root, "extensions/extension")
 272                 for ext in extensions:
 273                         self.parse_extension(ext)
 274
 275         def check_backport_extensions(self, api):
 276                 for e in api.extensions.itervalues():
 277                         if e.ext_type!="ARB":
 278                                 continue
 279
 280                         e.backport = True
 281                         for t in e.things.itervalues():
 282                                 if t.name.endswith(e.ext_type):
 283                                         e.backport = False
 284                                         break
 285
 286         def resolve_enum_aliases(self, api):
 287                 for e in api.extensions.itervalues():
 288                         ext_enums = filter((lambda t: t.kind==Thing.ENUM), e.things.itervalues())
 289                         enum_suffix = "_"+e.ext_type
 290                         for n in ext_enums:
 291                                 if n.api_support[api.name].core_version:
 292                                         continue
 293
 294                                 name = n.name
 295                                 if name.endswith(enum_suffix):
 296                                         name = name[:-len(enum_suffix)]
 297                                 ce = api.core_things.get(name)
 298                                 if ce and ce.value==n.value and ce.name not in n.aliases:
 299                                         n.aliases.append(ce.name)
 300
 301         def resolve_sources(self, api):
 302                 for e in api.extensions.itervalues():
 303                         for t in e.things.itervalues():
 304                                 for a in t.aliases:
 305                                         # There are a few cases where a vendor function is aliased to
 306                                         # an EXT or ARB function but those are rare and not relevant for
 307                                         # our use
 308                                         alias = api.core_things.get(a)
 309                                         if alias:
 310                                                 sources = alias.api_support[api.name].sources
 311                                                 if t not in sources:
 312                                                         sources.append(t)
 313
 314         def sort_extensions(self):
 315                 for t in self.things.itervalues():
 316                         for s in t.api_support.itervalues():
 317                                 s.extensions.sort(key=(lambda e: e.preference), reverse=True)
 318
 319         def finalize(self):
 320                 for a in self.apis.itervalues():
 321                         self.check_backport_extensions(a)
 322                         self.resolve_enum_aliases(a)
 323                         self.resolve_sources(a)
 324                 self.sort_extensions()
 325
 326
 327 def detect_core_version(host_api, things, debug=None):
 328         max_version = Version(1, 0)
 329         max_count = 0
 330         lower_count = 0
 331         missing = []
 332         for t in things:
 333                 supp = t.api_support.get(host_api.name)
 334                 if supp and supp.core_version:
 335                         if supp.core_version>max_version:
 336                                 max_version = supp.core_version
 337                                 lower_count += max_count
 338                                 max_count = 1
 339                         elif supp.core_version==max_version:
 340                                 max_count += 1
 341                         else:
 342                                 lower_count += 1
 343                 else:
 344                         missing.append(t)
 345
 346         if lower_count>max_count or (missing and len(missing)*2<lower_count+max_count):
 347                 print "Warning: Inconsistent core version %s"%max_version
 348
 349         if missing:
 350                 if debug:
 351                         print "---"
 352                         print "%d things missing from core:"%len(missing)
 353                         for t in missing:
 354                                 print "  "+t.name
 355                 return None
 356
 357         return max_version
 358
 359 def detect_deprecated_version(host_api, things, debug):
 360         min_version = None
 361         deprecated = []
 362         for t in things:
 363                 supp = t.api_support.get(host_api.name)
 364                 if supp and supp.deprecated_version:
 365                         if min_version is None:
 366                                 min_version = supp.deprecated_version
 367                         else:
 368                                 min_version = min(min_version, supp.deprecated_version)
 369                         deprecated.append(t)
 370
 371         if min_version and len(deprecated)*2<len(things):
 372                 print "Warning: Inconsistent deprecation version %s"%min_version
 373                 if debug:
 374                         print "---"
 375                         print "%d things are deprecated:"%len(deprecated)
 376                         for t in deprecated:
 377                                 print "  "+t.name
 378
 379         return min_version
 380
 381 def detect_backport_extension(host_api, things):
 382         candidates = []
 383         for t in things:
 384                 supp = t.api_support.get(host_api.name)
 385                 if supp and supp.core_version:
 386                         for e in supp.extensions:
 387                                 if e.backport and e not in candidates:
 388                                         candidates.append(e)
 389
 390         total_count = len(things)
 391         best_ext = None
 392         best_count = 0
 393         for e in candidates:
 394                 things_in_ext = filter((lambda t: t.name in e.things), things)
 395                 count = len(things_in_ext)
 396                 if count==total_count:
 397                         return e
 398                 elif count>best_count:
 399                         best_ext = e
 400                         best_count = count
 401
 402         if best_count*2>=total_count:
 403                 print "Warning: Inconsistent backport extension %s"%best_ext.name
 404
 405 def collect_extensions(thing, api, exts):
 406         supp = thing.api_support.get(api)
 407         if not supp:
 408                 return
 409
 410         for e in supp.extensions:
 411                 if not e.backport and e.ext_type!="MSP" and e not in exts:
 412                         exts.append(e)
 413
 414         for s in supp.sources:
 415                 collect_extensions(s, api, exts)
 416
 417 def detect_source_extension(host_api, things, debug=False):
 418         things_by_ext = {}
 419         for t in things:
 420                 exts = []
 421                 collect_extensions(t, host_api.name, exts)
 422                 for e in exts:
 423                         things_by_ext.setdefault(e, []).append(t)
 424
 425         if debug:
 426                 print "---"
 427                 print "Looking for %d things in %d extensions"%(len(things), len(things_by_ext))
 428
 429         extensions = []
 430         missing = set(things)
 431         while missing and things_by_ext:
 432                 largest_ext = None
 433                 largest_count = 0
 434                 for e, t in things_by_ext.iteritems():
 435                         count = len(t)
 436                         if count>largest_count:
 437                                 largest_ext = e
 438                                 largest_count = count
 439                         elif count==largest_count and e.preference>largest_ext.preference:
 440                                 largest_ext = e
 441
 442                 if debug:
 443                         print "Found %d things in %s"%(largest_count, largest_ext.name)
 444
 445                 extensions.append(largest_ext)
 446                 for t in things_by_ext[largest_ext]:
 447                         missing.remove(t)
 448                 if not missing:
 449                         break
 450
 451                 del things_by_ext[largest_ext]
 452                 for e in things_by_ext.keys():
 453                         unseen = filter((lambda t: t in missing), things_by_ext[e])
 454                         if unseen:
 455                                 things_by_ext[e] = unseen
 456                         else:
 457                                 del things_by_ext[e]
 458
 459         if missing:
 460                 if debug:
 461                         print "%d things still missing:"%len(missing)
 462                         for t in missing:
 463                                 print "  "+t.name
 464                 return None
 465
 466         return extensions
 467
 468
 469 class SourceGenerator:
 470         def __init__(self, host_api, ext_name, things, optional_things, debug=False):
 471                 self.host_api = host_api
 472                 self.api_prefix = "GL"
 473                 if self.host_api.name=="gles2":
 474                         self.api_prefix = "GL_ES"
 475                 self.ext_name = ext_name
 476                 all_things = things+optional_things
 477                 self.funcs = filter((lambda t: t.kind==Thing.FUNCTION), all_things)
 478                 self.funcs.sort(key=(lambda f: f.name))
 479                 self.func_typedefs = dict((f.name, "FPtr_"+f.name) for f in self.funcs)
 480                 self.enums = filter((lambda t: t.kind==Thing.ENUM), all_things)
 481                 self.enums.sort(key=(lambda e: e.value))
 482                 self.core_version = detect_core_version(host_api, things, debug)
 483                 self.deprecated_version = detect_deprecated_version(host_api, things, debug)
 484                 self.backport_ext = detect_backport_extension(host_api, things);
 485                 self.source_exts = detect_source_extension(host_api, things, debug)
 486
 487                 if not self.core_version and not self.backport_ext and not self.source_exts:
 488                         print "Warning: Not supportable on host API"
 489
 490         def dump_info(self):
 491                 print "--- Extension information ---"
 492                 print "Extension %s"%self.ext_name
 493                 print "Core %s"%self.core_version
 494                 print "Deprecated %s"%self.deprecated_version
 495                 if self.backport_ext:
 496                         print "Backport %s"%self.backport_ext.name
 497                 if self.source_exts:
 498                         print "Sources %s"%", ".join(e.name for e in self.source_exts)
 499
 500         def write_header_intro(self, out):
 501                 out.write("#ifndef MSP_GL_%s_\n"%self.ext_name.upper())
 502                 out.write("#define MSP_GL_%s_\n"%self.ext_name.upper())
 503
 504                 out.write("""
 505 #include <msp/gl/extension.h>
 506 #include <msp/gl/gl.h>
 507
 508 namespace Msp {
 509 namespace GL {
 510
 511 """)
 512
 513         def write_enum_definitions(self, out):
 514                 enums_by_category = {}
 515                 for e in self.enums:
 516                         cat = None
 517                         supp = e.api_support.get(self.host_api.name)
 518                         if supp:
 519                                 if supp.core_version:
 520                                         cat = "%s_%s"%(self.api_prefix, supp.core_version.as_define())
 521                                 elif supp.extensions:
 522                                         cat = "GL_"+supp.extensions[0].name
 523                         enums_by_category.setdefault(cat, []).append(e)
 524
 525                 for cat in sorted(enums_by_category.keys()):
 526                         if cat:
 527                                 out.write("#ifndef %s\n"%cat)
 528                         for e in enums_by_category[cat]:
 529                                 out.write("#define %s 0x%04X\n"%(e.name, e.value))
 530                         if cat:
 531                                 out.write("#endif\n")
 532                         out.write("\n")
 533
 534         def write_function_pointer_declarations(self, out):
 535                 for f in self.funcs:
 536                         typedef = self.func_typedefs[f.name]
 537                         out.write("typedef %s (APIENTRY *%s)(%s);\n"%(f.return_type, typedef, ", ".join(f.params)))
 538                         out.write("extern %s %s;\n"%(typedef, f.name))
 539                         out.write("\n")
 540
 541         def write_header_outro(self, out):
 542                 out.write("""
 543 } // namespace GL
 544 } // namespace Msp
 545
 546 #endif
 547 """)
 548
 549         def write_source_intro(self, out):
 550                 out.write("#include \"%s.h\"\n"%self.ext_name.lower())
 551                 if self.funcs:
 552                         out.write("""
 553 #ifdef __APPLE__
 554 #define GET_PROC_ADDRESS(x) &::x
 555 #else
 556 #define GET_PROC_ADDRESS(x) get_proc_address(#x)
 557 #endif
 558
 559 #ifdef _WIN32
 560 #define GET_PROC_ADDRESS_1_1(x) &::x
 561 #else
 562 #define GET_PROC_ADDRESS_1_1(x) GET_PROC_ADDRESS(x)
 563 #endif
 564 """)
 565                 out.write("""
 566 namespace Msp {
 567 namespace GL {
 568
 569 """)
 570
 571         def write_function_pointer_definitions(self, out):
 572                 for f in self.funcs:
 573                         out.write("%s %s = 0;\n"%(self.func_typedefs[f.name], f.name))
 574
 575         def write_init_function(self, out):
 576                 out.write("\nExtension::SupportLevel init_%s()\n{\n"%self.ext_name.lower())
 577                 if self.core_version:
 578                         out.write("\tif(is_disabled(\"GL_%s\"))\n\t\treturn Extension::UNSUPPORTED;\n"%self.ext_name)
 579                         out.write("#if !defined(__APPLE__) || defined(%s_%s)\n"%(self.api_prefix, self.core_version.as_define()))
 580                         out.write("\tif(")
 581                         if self.backport_ext:
 582                                 out.write("is_supported(\"GL_%s\") || "%self.backport_ext.name)
 583                         out.write("is_supported(%r"%self.core_version)
 584                         if self.deprecated_version:
 585                                 out.write(", %r"%self.deprecated_version)
 586                         out.write("))\n\t{\n")
 587                         for f in self.funcs:
 588                                 supp = f.api_support[self.host_api.name]
 589                                 gpa_suffix = ""
 590                                 if supp.core_version is not None and supp.core_version<=Version(1, 1):
 591                                         gpa_suffix = "_1_1"
 592                                 out.write("\t\t%s = reinterpret_cast<%s>(GET_PROC_ADDRESS%s(%s));\n"%(f.name, self.func_typedefs[f.name], gpa_suffix, f.name))
 593                         out.write("\t\treturn Extension::CORE;\n")
 594                         out.write("\t}\n")
 595                         out.write("#endif\n")
 596                 if self.source_exts:
 597                         out.write("#if !defined(__APPLE__) || defined(GL_%s)\n"%self.ext_name)
 598                         out.write("\tif(%s)\n\t{\n"%" && ".join("is_supported(\"GL_%s\")"%s.name for s in self.source_exts))
 599                         for f in self.funcs:
 600                                 supp = f.api_support[self.host_api.name]
 601                                 if supp.sources:
 602                                         src = None
 603                                         for e in self.source_exts:
 604                                                 for s in supp.sources:
 605                                                         if s.name in e.things:
 606                                                                 src = s
 607                                                                 break
 608                                                 if src:
 609                                                         break
 610                                 else:
 611                                         src = f
 612
 613                                 if src:
 614                                         out.write("\t\t%s = reinterpret_cast<%s>(GET_PROC_ADDRESS(%s));\n"%(f.name, self.func_typedefs[f.name], src.name))
 615                         out.write("\t\treturn Extension::EXTENSION;\n")
 616                         out.write("\t}\n")
 617                         out.write("#endif\n")
 618                 out.write("\treturn Extension::UNSUPPORTED;\n")
 619                 out.write("}\n")
 620
 621         def write_source_outro(self, out):
 622                 out.write("""
 623 } // namespace GL
 624 } // namespace Msp
 625 """)
 626
 627         def write_header(self, fn):
 628                 out = file(fn, "w")
 629                 self.write_header_intro(out)
 630                 self.write_enum_definitions(out)
 631                 self.write_function_pointer_declarations(out)
 632                 out.write("extern Extension %s;\n"%self.ext_name)
 633                 self.write_header_outro(out)
 634
 635         def write_source(self, fn):
 636                 out = file(fn, "w")
 637                 self.write_source_intro(out)
 638                 self.write_function_pointer_definitions(out)
 639                 self.write_init_function(out)
 640                 out.write("\nExtension %s(\"GL_%s\", init_%s);\n"%(self.ext_name, self.ext_name, self.ext_name.lower()))
 641                 self.write_source_outro(out)
 642
 643
 644 def dump_api_support(supp, api, indent):
 645         if supp.core_version:
 646                 print indent+"core in version "+str(supp.core_version)
 647         if supp.deprecated_version:
 648                 print indent+"deprecated in version "+str(supp.deprecated_version)
 649         for e in supp.extensions:
 650                 print indent+"extension %s (preference %d)"%(e.name, e.preference)
 651         for r in supp.sources:
 652                 print indent+"source "+r.name
 653                 dump_thing_info(r, api, indent+"  ")
 654
 655 def dump_thing_info(thing, api, indent):
 656         for a in thing.aliases:
 657                 print indent+"alias "+a
 658         if api:
 659                 supp = thing.api_support.get(api)
 660                 dump_api_support(supp, api, indent)
 661         else:
 662                 for a, s in thing.api_support.iteritems():
 663                         print indent+"api "+a
 664                         dump_api_support(s, a, indent+"  ")
 665
 666
 667 class ExtensionParser:
 668         def __init__(self, host_api):
 669                 self.host_api = host_api
 670                 self.target_ext = None
 671                 self.core_version = None
 672                 self.deprecated_version = None
 673                 self.backport_ext = None
 674                 self.ignore_things = []
 675                 self.optional_things = []
 676
 677         def parse(self, fn):
 678                 for line in open(fn):
 679                         line = line.strip()
 680                         if line.startswith("#"):
 681                                 continue
 682
 683                         parts = line.split()
 684                         api = None
 685                         keyword = parts[0]
 686                         if ":" in keyword:
 687                                 api, keyword = keyword.split(":")
 688
 689                         if api is not None and api!=self.host_api:
 690                                 continue
 691
 692                         if keyword=="extension":
 693                                 self.target_ext = parts[1]
 694                         elif keyword=="core_version":
 695                                 self.core_version = Version(*map(int, parts[1].split('.')))
 696                         elif keyword=="deprecated":
 697                                 self.deprecated_version = Version(*map(int, parts[1].split('.')))
 698                         elif keyword=="backport":
 699                                 self.backport_ext = parts[1]
 700                         elif keyword=="ignore":
 701                                 self.ignore_things.append(parts[1])
 702                         elif keyword=="optional":
 703                                 self.optional_things.append(parts[1])
 704                         else:
 705                                 print "Unknown keyword "+keyword
 706                                 return False
 707
 708                 return True
 709
 710
 711 def get_extension(api_map, ext_name):
 712         if "." in ext_name:
 713                 ext_api_name, ext_name = ext_name.split(".")
 714         else:
 715                 ext_api_name = "gl"
 716
 717         return api_map[ext_api_name].extensions[ext_name]
 718
 719 def resolve_things(api, things):
 720         rthings = []
 721         for t in things:
 722                 ct = filter(None, map(api.core_things.get, t.aliases))
 723                 if ct:
 724                         rthings += ct
 725                 else:
 726                         rthings.append(t)
 727
 728         return rthings
 729
 730 def collect_extension_things(host_api, target_ext, ignore):
 731         ext_things = [t for n, t in target_ext.things.iteritems() if n not in ignore]
 732         return resolve_things(target_ext.api, ext_things)
 733
 734 def collect_optional_things(target_ext, names):
 735         things = []
 736         for t in names:
 737                 if t in target_ext.things:
 738                         things.append(target_ext.things[t])
 739                 else:
 740                         things.append(target_ext.api.core_things[t])
 741         return resolve_things(target_ext.api, things)
 742
 743 def main():
 744         if len(sys.argv)<2:
 745                 print """Usage:
 746   extgen.py [api] <extfile> [<outfile>]
 747
 748 Reads gl.xml and generates C++ source files to use an OpenGL extension
 749 described in <extfile>.  If <outfile> is absent, the extension's lowercased
 750 name is used.  Anything after the last dot in <outfile> is removed and
 751 replaced with cpp and h."""
 752                 sys.exit(1)
 753
 754         i = 1
 755
 756         debug = False
 757         if sys.argv[i]=="-g":
 758                 debug = True
 759                 i += 1
 760
 761         host_api_name = "gl"
 762         if sys.argv[i].startswith("gl"):
 763                 host_api_name = sys.argv[i]
 764                 i += 1
 765
 766         ext_parser = ExtensionParser(host_api_name)
 767         if not ext_parser.parse(sys.argv[i]):
 768                 sys.exit(1)
 769         i += 1
 770
 771         if i<len(sys.argv):
 772                 out_base = os.path.splitext(sys.argv[i])[0]
 773         else:
 774                 out_base = ext_parser.target_ext.lower()
 775
 776         xml_parser = GlXmlParser()
 777         xml_parser.parse_file("gl.xml")
 778         xml_parser.parse_file("gl.fixes.xml")
 779         xml_parser.parse_file("gl.msp.xml")
 780         xml_parser.finalize()
 781
 782         host_api = xml_parser.apis[host_api_name]
 783         target_ext = get_extension(xml_parser.apis, ext_parser.target_ext)
 784         things = collect_extension_things(host_api, target_ext, ext_parser.ignore_things+ext_parser.optional_things)
 785         optional_things = collect_optional_things(target_ext, ext_parser.optional_things)
 786
 787         if debug:
 788                 print "--- Things included in this extension ---"
 789                 all_things = things+optional_things
 790                 all_things.sort(key=(lambda t: t.name))
 791                 for t in all_things:
 792                         print t.name
 793                         if t in optional_things:
 794                                 print "  optional"
 795                         dump_thing_info(t, None, "  ")
 796
 797         generator = SourceGenerator(host_api, target_ext.name, things, optional_things, debug)
 798         if ext_parser.core_version:
 799                 generator.core_version = ext_parser.core_version
 800         if ext_parser.deprecated_version:
 801                 generator.deprecated_version = ext_parser.deprecated_version
 802         if ext_parser.backport_ext:
 803                 if ext_parser.backport_ext=="none":
 804                         generator.backport_ext = None
 805                 else:
 806                         generator.backport_ext = get_extension(xml_parser.apis, ext_parser.backport_ext)
 807         if debug:
 808                 generator.dump_info()
 809         generator.write_header(out_base+".h")
 810         generator.write_source(out_base+".cpp")
 811
 812 if __name__=="__main__":
 813         main()