specs/scripts: Cleanup.

1 files changed, 293 insertions, 0 deletions

diff --git a/specs/scripts/spec2api.py b/specs/scripts/spec2api.py
new file mode 100755
index 00000000..f21b08d5
--- /dev/null
+++ b/specs/scripts/spec2api.py
@@ -0,0 +1,293 @@
+#!/usr/bin/env python
+##########################################################################
+#
+# Copyright 2010 VMware, Inc.
+# 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 the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, 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 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 NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS 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.
+#
+##########################################################################/
+
+"""Parser for OpenGL .spec files in http://www.opengl.org/registry/."""
+
+
+import sys
+import re
+import optparse
+
+
+def stderr(x):
+    sys.stderr.write(str(x) + '\n')
+
+
+class Parser:
+
+    def __init__(self, stream):
+        pass
+
+
+class LineParser:
+    """Base class for parsers that read line-based formats."""
+
+    def __init__(self, stream):
+        self._stream = stream
+        self._line = None
+        self._eof = False
+        # read lookahead
+        self.readline()
+    
+    def parse(self):
+        raise NotImplementedError
+
+    def readline(self):
+        line = self._stream.readline()
+        if not line:
+            self._line = ''
+            self._eof = True
+        self._line = line.rstrip('\r\n')
+
+    def lookahead(self):
+        assert self._line is not None
+        return self._line
+
+    def consume(self):
+        assert self._line is not None
+        line = self._line
+        self.readline()
+        return line
+
+    def eof(self):
+        assert self._line is not None
+        return self._eof
+    
+    def skip_whitespace(self):
+        while not self.eof() and self.match_whitespace() or self.match_comment():
+            self.consume()
+
+    def match_whitespace(self):
+        line = self.lookahead()
+        return not line.strip()
+
+    def match_comment(self):
+        return False
+
+
+class TypemapParser(LineParser):
+
+    def parse(self):
+        typemap = {}
+        self.skip_whitespace()
+        while not self.eof():
+            line = self.consume()
+            fields = [field.strip() for field in line.split(',')]
+            src = fields[0]
+            dst = fields[3]
+            if dst != '*':
+                typemap[src] = dst
+            self.skip_whitespace()
+        return typemap
+    
+    def match_comment(self):
+        line = self.lookahead()
+        return line.startswith('#')
+
+
+class SpecParser(LineParser):
+
+    property_re = re.compile(r'^\w+:')
+    prototype_re = re.compile(r'^(\w+)\((.*)\)$')
+
+    def __init__(self, stream, prefix='', typemap = None):
+        LineParser.__init__(self, stream)
+        if typemap is None:
+            self.typemap = {}
+        else:
+            self.typemap = typemap
+        self.prefix = prefix
+        self.category = None
+
+    def parse(self):
+        self.skip_whitespace()
+        while not self.eof():
+            line = self.lookahead()
+            if self.property_re.match(line):
+                self.parse_property()
+            elif self.prototype_re.match(line):
+                self.parse_prototype()
+            else:
+                self.consume()
+            self.skip_whitespace()
+
+    def parse_property(self):
+        line = self.consume()
+        name, value = line.split(':', 1)
+        if name == 'category':
+            values = value.split()
+            #self.prefix = values[0]
+
+    get_function_re = re.compile(r'^(Get|Is|Are)[A-Z]\w+')
+
+    def parse_prototype(self):
+        line = self.consume()
+        mo = self.prototype_re.match(line)
+        function_name, arg_names = mo.groups()
+        arg_names = [arg_name.strip() for arg_name in arg_names.split(',') if arg_name.strip()]
+        
+        extra = ''
+        if self.get_function_re.match(function_name):
+            extra += ', sideeffects=False'
+        function_name = self.prefix + function_name
+
+        ret_type = 'Void'
+        arg_types = {}
+        category = None
+        line = self.lookahead()
+        while line.startswith('\t'):
+            fields = line.split(None, 2)
+            if fields[0] == 'return':
+                ret_type = self.parse_type(fields[1])
+            elif fields[0] == 'param':
+                arg_name, arg_type = fields[1:3]
+                arg_types[fields[1]] = self.parse_arg(function_name, arg_name, arg_type)
+            elif fields[0] == 'category':
+                category = fields[1]
+            else:
+                pass
+            self.consume()
+            line = self.lookahead()
+        self.consume()
+        args = [arg_types[arg_name] for arg_name in arg_names]
+
+        if category is not None:
+            if category == self.prefix:
+                category = self.prefix.upper()
+            else:
+                category = self.prefix.upper() + '_' + category
+            if category != self.category:
+                if self.category is not None:
+                    print
+                print '    # %s' % category
+                self.category = category
+
+        if self.prefix == 'wgl':
+            constructor = 'StdFunction'
+        else:
+            constructor = 'GlFunction'
+
+        print '    %s(%s, "%s", [%s]%s),' % (constructor, ret_type, function_name, ', '.join(args), extra)
+
+    array_re = re.compile(r'^array\s+\[(.*)\]$')
+
+    string_typemap = {
+        'GLchar': 'GLstring',
+        'GLcharARB': 'GLstringARB',
+    }
+
+    def parse_arg(self, function_name, arg_name, arg_type):
+        orig_type, inout, kind = arg_type.split(' ', 2)
+
+        base_type = self.parse_type(orig_type)
+
+        if kind == 'value':
+            arg_type = base_type
+        elif kind == 'reference':
+            if inout == 'in':
+                base_type = 'Const(%s)' % base_type
+            arg_type = 'Pointer(%s)' % base_type
+        elif kind.startswith("array"):
+            if inout == 'in':
+                base_type = 'Const(%s)' % base_type
+
+            arg_type = 'OpaquePointer(%s)' % base_type
+
+            if base_type in ('Void', 'void', 'GLvoid'):
+                constructor = 'Blob'
+            else:
+                constructor = 'Array'
+
+            mo = self.array_re.match(kind)
+            if mo:
+                length = mo.group(1).strip()
+                if length == '':
+                    try:
+                        arg_type = self.string_typemap[base_type]
+                    except KeyError:
+                        pass
+                elif length == '1':
+                    arg_type = 'Pointer(%s)' % base_type
+                elif length.find("COMPSIZE") == -1:
+                    try:
+                        int(length)
+                    except ValueError:
+                        length = '"%s"' % length
+                    arg_type = '%s(%s, %s)' % (constructor, base_type, length)
+                else:
+                    if length == "COMPSIZE(pname)":
+                        length = "_gl_param_size(pname)"
+                        arg_type = '%s(%s, "%s")' % (constructor, base_type, length)
+                    else:
+                        length = length.replace("COMPSIZE", "_%s_size" % function_name)
+                        length = length.replace("/", ", ")
+                        arg_type = 'Opaque%s(%s, "%s")' % (constructor, base_type, length)
+        else:
+            assert False
+        
+        arg = '(%s, "%s")' % (arg_type, arg_name)
+        if inout == 'out':
+            arg = 'Out' + arg
+        return arg
+
+    semantic_typemap = {
+        'String': 'CString',
+        'Texture': 'GLtexture',
+    }
+
+    post_typemap = {
+        'void': 'Void',
+        'int': 'Int',
+        'float': 'Float',
+    }
+
+    def parse_type(self, type):
+        try:
+            return self.semantic_typemap[type]
+        except KeyError:
+            pass
+        type = self.typemap.get(type, type)
+        type = self.post_typemap.get(type, type)
+        return type
+
+    def match_comment(self):
+        line = self.lookahead()
+        return line.startswith('#')
+
+
+def main():
+    prefix = sys.argv[1]
+
+    parser = TypemapParser(open(sys.argv[2], 'rt'))
+    typemap = parser.parse()
+
+    for arg in sys.argv[3:]:
+        parser = SpecParser(open(arg, 'rt'), prefix=prefix, typemap=typemap)
+        parser.parse()
+    
+
+if __name__ == '__main__':
+    main()