path: root/src/mesa/es/glapi/gl_parse_header.py

#!/usr/bin/python
#
# Copyright (C) 2009 Chia-I Wu <olv@0xlab.org>
#
# 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
# on the rights to use, copy, modify, merge, publish, distribute, sub
# license, 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 (including the next
# paragraph) 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 NON-INFRINGEMENT.  IN NO EVENT SHALL
# IBM AND/OR ITS SUPPLIERS 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.

import sys
import os.path
import getopt
import re

GLAPI = "../../glapi/gen"
sys.path.append(GLAPI)

class HeaderParser(object):
    """Parser for GL header files."""

    def __init__(self, verbose=0):
        # match #if and #ifdef
        self.IFDEF = re.compile('#\s*if(n?def\s+(?P<ifdef>\w+)|\s+(?P<if>.+))')
        # match #endif
        self.ENDIF = re.compile('#\s*endif')
        # match typedef abc def;
        self.TYPEDEF = re.compile('typedef\s+(?P<from>[\w ]+)\s+(?P<to>\w+);')
        # match #define XYZ VAL
        self.DEFINE = re.compile('#\s*define\s+(?P<key>\w+)(?P<value>\s+[\w"]*)?')
        # match GLAPI
        self.GLAPI = re.compile('^GL_?API(CALL)?\s+(?P<return>[\w\s*]+[\w*])\s+(GL)?_?APIENTRY\s+(?P<name>\w+)\s*\((?P<params>[\w\s(,*\[\])]+)\)\s*;')

        self.split_params = re.compile('\s*,\s*')
        self.split_ctype = re.compile('(\W)')
        # ignore GL_VERSION_X_Y
        self.ignore_enum = re.compile('GL(_ES)?_VERSION(_ES_C[ML])?_\d_\d')

        self.verbose = verbose
        self._reset()

    def _reset(self):
        """Reset to initial state."""
        self.ifdef_levels = []
        self.need_char = False

    # use typeexpr?
    def _format_ctype(self, ctype, fix=True):
        """Format a ctype string, optionally fix it."""
        # split the type string
        tmp = self.split_ctype.split(ctype)
        tmp = [s for s in tmp if s and s != " "]

        pretty = ""
        for i in xrange(len(tmp)):
            # add missing GL prefix
            if (fix and tmp[i] != "const" and tmp[i] != "*" and
                not tmp[i].startswith("GL")):
                tmp[i] = "GL" + tmp[i]

            if i == 0:
                pretty = tmp[i]
            else:
                sep = " "
                if tmp[i - 1] == "*":
                    sep = ""
                pretty += sep + tmp[i]
        return pretty

    # use typeexpr?
    def _get_ctype_attrs(self, ctype):
        """Get the attributes of a ctype."""
        is_float = (ctype.find("float") != -1 or ctype.find("double") != -1)
        is_signed = not (ctype.find("unsigned")  != -1)

        size = 0
        if ctype.find("char") != -1:
            size = 1
        elif ctype.find("short") != -1:
            size = 2
        elif ctype.find("int") != -1:
            size = 4
        elif is_float:
            if ctype.find("float") != -1:
                size = 4
            else:
                size = 8

        return (size, is_float, is_signed)

    def _parse_define(self, line):
        """Parse a #define line for an <enum>."""
        m = self.DEFINE.search(line)
        if not m:
            if self.verbose and line.find("#define") >= 0:
                print "ignore %s" % (line)
            return None

        key = m.group("key").strip()
        val = m.group("value").strip()

        # enum must begin with GL_ and be all uppercase
        if ((not (key.startswith("GL_") and key.isupper())) or
            (self.ignore_enum.match(key) and val == "1")):
            if self.verbose:
                print "ignore enum %s" % (key)
            return None

        return (key, val)

    def _parse_typedef(self, line):
        """Parse a typedef line for a <type>."""
        m = self.TYPEDEF.search(line)
        if not m:
            if self.verbose and line.find("typedef") >= 0:
                print "ignore %s" % (line)
            return None

        f = m.group("from").strip()
        t = m.group("to").strip()
        if not t.startswith("GL"):
            if self.verbose:
                print "ignore type %s" % (t)
            return None
        attrs = self._get_ctype_attrs(f)

        return (f, t, attrs)

    def _parse_gl_api(self, line):
        """Parse a GLAPI line for a <function>."""
        m = self.GLAPI.search(line)
        if not m:
            if self.verbose and line.find("APIENTRY") >= 0:
                print "ignore %s" % (line)
            return None

        rettype = m.group("return")
        rettype = self._format_ctype(rettype)
        if rettype == "GLvoid":
            rettype = ""

        name = m.group("name")

        param_str = m.group("params")
        chunks = self.split_params.split(param_str)
        chunks = [s.strip() for s in chunks]
        if len(chunks) == 1 and (chunks[0] == "void" or chunks[0] == "GLvoid"):
            chunks = []

        params = []
        for c in chunks:
            # split type and variable name
            idx = c.rfind("*")
            if idx < 0:
                idx = c.rfind(" ")
            if idx >= 0:
                idx += 1
                ctype = c[:idx]
                var = c[idx:]
            else:
                ctype = c
                var = "unnamed"

            # convert array to pointer
            idx = var.find("[")
            if idx >= 0:
                var = var[:idx]
                ctype += "*"

            ctype = self._format_ctype(ctype)
            var = var.strip()

            if not self.need_char and ctype.find("GLchar") >= 0:
                self.need_char = True

            params.append((ctype, var))

        return (rettype, name, params)

    def _change_level(self, line):
        """Parse a #ifdef line and change level."""
        m = self.IFDEF.search(line)
        if m:
            ifdef = m.group("ifdef")
            if not ifdef:
                ifdef = m.group("if")
            self.ifdef_levels.append(ifdef)
            return True
        m = self.ENDIF.search(line)
        if m:
            self.ifdef_levels.pop()
            return True
        return False

    def _read_header(self, header):
        """Open a header file and read its contents."""
        lines = []
        try:
            fp = open(header, "rb")
            lines = fp.readlines()
            fp.close()
        except IOError, e:
            print "failed to read %s: %s" % (header, e)
        return lines

    def _cmp_enum(self, enum1, enum2):
        """Compare two enums."""
        # sort by length of the values as strings
        val1 = enum1[1]
        val2 = enum2[1]
        ret = len(val1) - len(val2)
        # sort by the values
        if not ret:
            val1 = int(val1, 16)
            val2 = int(val2, 16)
            ret = val1 - val2
            # in case int cannot hold the result
            if ret > 0:
                ret = 1
            elif ret < 0:
                ret = -1
        # sort by the names
        if not ret:
            if enum1[0] < enum2[0]:
                ret = -1
            elif enum1[0] > enum2[0]:
                ret = 1
        return ret

    def _cmp_type(self, type1, type2):
        """Compare two types."""
        attrs1 = type1[2]
        attrs2 = type2[2]
        # sort by type size
        ret = attrs1[0] - attrs2[0]
        # float is larger
        if not ret:
            ret = attrs1[1] - attrs2[1]
        # signed is larger
        if not ret:
            ret = attrs1[2] - attrs2[2]
        # reverse
        ret = -ret
        return ret

    def _cmp_function(self, func1, func2):
        """Compare two functions."""
        name1 = func1[1]
        name2 = func2[1]
        ret = 0
        # sort by the names
        if name1 < name2:
            ret = -1
        elif name1 > name2:
            ret = 1
        return ret

    def _postprocess_dict(self, hdict):
        """Post-process a header dict and return an ordered list."""
        hlist = []
        largest = 0
        for key, cat in hdict.iteritems():
            size = len(cat["enums"]) + len(cat["types"]) + len(cat["functions"])
            # ignore empty category
            if not size:
                continue

            cat["enums"].sort(self._cmp_enum)
            # remove duplicates
            dup = []
            for i in xrange(1, len(cat["enums"])):
                if cat["enums"][i] == cat["enums"][i - 1]:
                    dup.insert(0, i)
            for i in dup:
                e = cat["enums"].pop(i)
                if self.verbose:
                    print "remove duplicate enum %s" % e[0]

            cat["types"].sort(self._cmp_type)
            cat["functions"].sort(self._cmp_function)

            # largest category comes first
            if size > largest:
                hlist.insert(0, (key, cat))
                largest = size
            else:
                hlist.append((key, cat))
        return hlist

    def parse(self, header):
        """Parse a header file."""
        self._reset()

        if self.verbose:
            print "Parsing %s" % (header)

        hdict = {}
        lines = self._read_header(header)
        for line in lines:
            if self._change_level(line):
                continue

            # skip until the first ifdef (i.e. __gl_h_)
            if not self.ifdef_levels:
                continue

            cat_name = os.path.basename(header)
            # check if we are in an extension
            if (len(self.ifdef_levels) > 1 and
                self.ifdef_levels[-1].startswith("GL_")):
                cat_name = self.ifdef_levels[-1]

            try:
                cat = hdict[cat_name]
            except KeyError:
                cat = {
                        "enums": [],
                        "types": [],
                        "functions": []
                }
                hdict[cat_name] = cat

            key = "enums"
            elem = self._parse_define(line)
            if not elem:
                key = "types"
                elem = self._parse_typedef(line)
            if not elem:
                key = "functions"
                elem = self._parse_gl_api(line)

            if elem:
                cat[key].append(elem)

        if self.need_char:
            if self.verbose:
                print "define GLchar"
            elem = self._parse_typedef("typedef char GLchar;")
            cat["types"].append(elem)
        return self._postprocess_dict(hdict)

def spaces(n, str=""):
    spaces = n - len(str)
    if spaces < 1:
        spaces = 1
    return " " * spaces

def output_xml(name, hlist):
    """Output a parsed header in OpenGLAPI XML."""

    for i in xrange(len(hlist)):
        cat_name, cat = hlist[i]

        print '<category name="%s">' % (cat_name)
        indent = 4

        for enum in cat["enums"]:
            name = enum[0][3:]
            value = enum[1]
            tab = spaces(41, name)
            attrs = 'name="%s"%svalue="%s"' % (name, tab, value)
            print '%s<enum %s/>' % (spaces(indent), attrs)

        if cat["enums"] and cat["types"]:
            print

        for type in cat["types"]:
            ctype = type[0]
            size, is_float, is_signed = type[2]

            attrs = 'name="%s"' % (type[1][2:])
            attrs += spaces(16, attrs) + 'size="%d"' % (size)
            if is_float:
                attrs += ' float="true"'
            elif not is_signed:
                attrs += ' unsigned="true"'

            print '%s<type %s/>' % (spaces(indent), attrs)

        for func in cat["functions"]:
            print
            ret = func[0]
            name = func[1][2:]
            params = func[2]

            attrs = 'name="%s" offset="assign"' % name
            print '%s<function %s>' % (spaces(indent), attrs)

            for param in params:
                attrs = 'name="%s" type="%s"' % (param[1], param[0])
                print '%s<param %s/>' % (spaces(indent * 2), attrs)
            if ret:
                attrs = 'type="%s"' % ret
                print '%s<return %s/>' % (spaces(indent * 2), attrs)

            print '%s</function>' % spaces(indent)

        print '</category>'
        print

def show_usage():
    print "Usage: %s [-v] <header> ..." % sys.argv[0]
    sys.exit(1)

def main():
    try:
        args, headers = getopt.getopt(sys.argv[1:], "v")
    except Exception, e:
        show_usage()
    if not headers:
        show_usage()

    verbose = 0
    for arg in args:
        if arg[0] == "-v":
            verbose += 1

    need_xml_header = True
    parser = HeaderParser(verbose)
    for h in headers:
        h = os.path.abspath(h)
        hlist = parser.parse(h)

        if need_xml_header:
            print '<?xml version="1.0"?>'
            print '<!DOCTYPE OpenGLAPI SYSTEM "%s/gl_API.dtd">' % GLAPI
            need_xml_header = False

        print
        print '<!-- %s -->' % (h)
        print '<OpenGLAPI>'
        print
        output_xml(h, hlist)
        print '</OpenGLAPI>'

if __name__ == '__main__':
    main()