[mesa.git] / src / mesa / glapi / gl_XML.py

#!/usr/bin/env python

# (C) Copyright IBM Corporation 2004, 2005
# 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
# 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.
#
# Authors:
#    Ian Romanick <idr@us.ibm.com>

import libxml2
import re, sys, string
import typeexpr


def parse_GL_API( file_name, factory = None ):
        doc = libxml2.readFile( file_name, None, libxml2.XML_PARSE_XINCLUDE + libxml2.XML_PARSE_NOBLANKS + libxml2.XML_PARSE_DTDVALID + libxml2.XML_PARSE_DTDATTR + libxml2.XML_PARSE_DTDLOAD + libxml2.XML_PARSE_NOENT )
        ret = doc.xincludeProcess()

        if not factory:
                factory = gl_item_factory()

        api = factory.create_item( "api", None, None )
        api.process_element( doc )

        doc.freeDoc()

        return api


def is_attr_true( element, name ):
        """Read a name value from an element's attributes.
        
        The value read from the attribute list must be either 'true' or
        'false'.  If the value is 'false', zero will be returned.  If the
        value is 'true', non-zero will be returned.  An exception will be
        raised for any other value."""

        value = element.nsProp( name, None )
        if value == "true":
                return 1
        elif value == "false":
                return 0
        else:
                raise RuntimeError('Invalid value "%s" for boolean "%s".' % (value, name))


class gl_print_base:
        """Base class of all API pretty-printers.

        In the model-view-controller pattern, this is the view.  Any derived
        class will want to over-ride the printBody, printRealHader, and
        printRealFooter methods.  Some derived classes may want to over-ride
        printHeader and printFooter, or even Print (though this is unlikely).
        """

        def __init__(self):
                # Name of the script that is generating the output file.
                # Every derived class should set this to the name of its
                # source file.

                self.name = "a"


                # License on the *generated* source file.  This may differ
                # from the license on the script that is generating the file.
                # Every derived class should set this to some reasonable
                # value.
                #
                # See license.py for an example of a reasonable value.

                self.license = "The license for this file is unspecified."

                
                # The header_tag is the name of the C preprocessor define
                # used to prevent multiple inclusion.  Typically only
                # generated C header files need this to be set.  Setting it
                # causes code to be generated automatically in printHeader
                # and printFooter.

                self.header_tag = None

                
                # List of file-private defines that must be undefined at the
                # end of the file.  This can be used in header files to define
                # names for use in the file, then undefine them at the end of
                # the header file.

                self.undef_list = []
                return


        def Print(self, api):
                self.printHeader()
                self.printBody(api)
                self.printFooter()
                return


        def printHeader(self):
                """Print the header associated with all files and call the printRealHeader method."""

                print '/* DO NOT EDIT - This file generated automatically by %s script */' \
                        % (self.name)
                print ''
                print '/*'
                print ' * ' + self.license.replace('\n', '\n * ')
                print ' */'
                print ''
                if self.header_tag:
                    print '#if !defined( %s )' % (self.header_tag)
                    print '#  define %s' % (self.header_tag)
                    print ''
                self.printRealHeader();
                return


        def printFooter(self):
                """Print the header associated with all files and call the printRealFooter method."""

                self.printRealFooter()

                if self.undef_list:
                        print ''
                        for u in self.undef_list:
                                print "#  undef %s" % (u)

                if self.header_tag:
                        print ''
                        print '#endif /* !defined( %s ) */' % (self.header_tag)


        def printRealHeader(self):
                """Print the "real" header for the created file.

                In the base class, this function is empty.  All derived
                classes should over-ride this function."""
                return


        def printRealFooter(self):
                """Print the "real" footer for the created file.

                In the base class, this function is empty.  All derived
                classes should over-ride this function."""
                return


        def printPure(self):
                """Conditionally define `PURE' function attribute.

                Conditionally defines a preprocessor macro `PURE' that wraps
                GCC's `pure' function attribute.  The conditional code can be
                easilly adapted to other compilers that support a similar
                feature.

                The name is also added to the file's undef_list.
                """
                self.undef_list.append("PURE")
                print """#  if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96)
#    define PURE __attribute__((pure))
#  else
#    define PURE
#  endif"""
                return


        def printFastcall(self):
                """Conditionally define `FASTCALL' function attribute.

                Conditionally defines a preprocessor macro `FASTCALL' that
                wraps GCC's `fastcall' function attribute.  The conditional
                code can be easilly adapted to other compilers that support a
                similar feature.

                The name is also added to the file's undef_list.
                """

                self.undef_list.append("FASTCALL")
                print """#  if defined(__i386__) && defined(__GNUC__)
#    define FASTCALL __attribute__((fastcall))
#  else
#    define FASTCALL
#  endif"""
                return


        def printVisibility(self, S, s):
                """Conditionally define visibility function attribute.

                Conditionally defines a preprocessor macro name S that wraps
                GCC's visibility function attribute.  The visibility used is
                the parameter s.  The conditional code can be easilly adapted
                to other compilers that support a similar feature.

                The name is also added to the file's undef_list.
                """

                self.undef_list.append(S)
                print """#  if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)
#    define %s  __attribute__((visibility("%s")))
#  else
#    define %s
#  endif""" % (S, s, S)
                return


        def printNoinline(self):
                """Conditionally define `NOINLINE' function attribute.

                Conditionally defines a preprocessor macro `NOINLINE' that
                wraps GCC's `noinline' function attribute.  The conditional
                code can be easilly adapted to other compilers that support a
                similar feature.

                The name is also added to the file's undef_list.
                """

                self.undef_list.append("NOINLINE")
                print """#  if defined(__GNUC__)
#    define NOINLINE __attribute__((noinline))
#  else
#    define NOINLINE
#  endif"""
                return


        def printHaveAlias(self):
                """Conditionally define `HAVE_ALIAS'.

                Conditionally defines a preprocessor macro `HAVE_ALIAS'.  The
                existance of this macro can be used to determine whether or
                not GCC's alias function attribute can be used.

                The name is also added to the file's undef_list.
                """

                self.undef_list.append("HAVE_ALIAS")
                print """#  if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
#    define HAVE_ALIAS
#  endif"""
                return


def real_function_name(element):
        name = element.nsProp( "name", None )
        alias = element.nsProp( "alias", None )
        
        if alias:
                return alias
        else:
                return name


class gl_item:
        def __init__(self, element, context):
                self.context = context

                self.name = element.nsProp( "name", None )

                c = element.parent.nsProp( "name", None )
                if re.compile("[1-9][0-9]*[.][0-9]+").match(c):
                        self.category = "GL_VERSION_" + c.replace(".", "_")
                else:
                        self.category = c

                return


class gl_type( gl_item ):
        def __init__(self, element, context):
                gl_item.__init__(self, element, context)
                self.size = int( element.nsProp( "size", None ), 0 )

                te = typeexpr.type_expression( None )
                tn = typeexpr.type_node()
                tn.size = int( element.nsProp( "size", None ), 0 )
                tn.integer = not is_attr_true( element, "float" )
                tn.unsigned = is_attr_true( element, "unsigned" )
                tn.name = "GL" + self.name
                te.set_base_type_node( tn )

                self.type_expr = te
                return
        

        def get_type_expression(self):
                return self.type_expr


class gl_enum( gl_item ):
        def __init__(self, element, context):
                gl_item.__init__(self, element, context)
                self.value = int( element.nsProp( "value", None ), 0 )

                temp = element.nsProp( "count", None )
                if not temp or temp == "?":
                        self.default_count = -1
                else:
                        try:
                                c = int(temp)
                        except Exception,e:
                                raise RuntimeError('Invalid count value "%s" for enum "%s" in function "%s" when an integer was expected.' % (temp, self.name, n))

                        self.default_count = c

                return


        def priority(self):
                """Calculate a 'priority' for this enum name.
                
                When an enum is looked up by number, there may be many
                possible names, but only one is the 'prefered' name.  The
                priority is used to select which name is the 'best'.

                Highest precedence is given to core GL name.  ARB extension
                names have the next highest, followed by EXT extension names.
                Vendor extension names are the lowest.
                """

                if self.name.endswith( "_BIT" ):
                        bias = 1
                else:
                        bias = 0

                if self.category.startswith( "GL_VERSION_" ):
                        priority = 0
                elif self.category.startswith( "GL_ARB_" ):
                        priority = 2
                elif self.category.startswith( "GL_EXT_" ):
                        priority = 4
                else:
                        priority = 6

                return priority + bias



class gl_parameter:
        def __init__(self, element, context):
                self.name = element.nsProp( "name", None )

                ts = element.nsProp( "type", None )
                self.type_expr = typeexpr.type_expression( ts, context )

                temp = element.nsProp( "variable_param", None )
                if temp:
                        self.count_parameter_list = temp.split( ' ' )
                else:
                        self.count_parameter_list = []

                # The count tag can be either a numeric string or the name of
                # a variable.  If it is the name of a variable, the int(c)
                # statement will throw an exception, and the except block will
                # take over.

                c = element.nsProp( "count", None )
                try: 
                        count = int(c)
                        self.count = count
                        self.counter = None
                except Exception,e:
                        count = 1
                        self.count = 0
                        self.counter = c
                
                self.count_scale = int(element.nsProp( "count_scale", None ))

                elements = (count * self.count_scale)
                if elements == 1:
                        elements = 0

                #if ts == "GLdouble":
                #       print '/* stack size -> %s = %u (before)*/' % (self.name, self.type_expr.get_stack_size())
                #       print '/* # elements = %u */' % (elements)
                self.type_expr.set_elements( elements )
                #if ts == "GLdouble":
                #       print '/* stack size -> %s = %u (after) */' % (self.name, self.type_expr.get_stack_size())

                self.is_counter = is_attr_true( element, 'counter' )
                self.is_output  = is_attr_true( element, 'output' )


                # Pixel data has special parameters.

                self.width      = element.nsProp('img_width',  None)
                self.height     = element.nsProp('img_height', None)
                self.depth      = element.nsProp('img_depth',  None)
                self.extent     = element.nsProp('img_extent', None)

                self.img_xoff   = element.nsProp('img_xoff',   None)
                self.img_yoff   = element.nsProp('img_yoff',   None)
                self.img_zoff   = element.nsProp('img_zoff',   None)
                self.img_woff   = element.nsProp('img_woff',   None)

                self.img_format = element.nsProp('img_format', None)
                self.img_type   = element.nsProp('img_type',   None)
                self.img_target = element.nsProp('img_target', None)

                self.img_pad_dimensions = is_attr_true( element, 'img_pad_dimensions' )
                self.img_null_flag      = is_attr_true( element, 'img_null_flag' )
                self.img_send_null      = is_attr_true( element, 'img_send_null' )

                return


        def compatible(self, other):
                return 1


        def is_array(self):
                return self.is_pointer()


        def is_pointer(self):
                return self.type_expr.is_pointer()


        def is_image(self):
                if self.width:
                        return 1
                else:
                        return 0


        def is_variable_length(self):
                return len(self.count_parameter_list) or self.counter


        def is_64_bit(self):
                count = self.type_expr.get_element_count()
                if count:
                        if (self.size() / count) == 8:
                                return 1
                else:
                        if self.size() == 8:
                                return 1

                return 0


        def string(self):
                return self.type_expr.original_string + " " + self.name


        def type_string(self):
                return self.type_expr.original_string


        def get_base_type_string(self):
                return self.type_expr.get_base_name()


        def get_dimensions(self):
                if not self.width:
                        return [ 0, "0", "0", "0", "0" ]

                dim = 1
                w = self.width
                h = "1"
                d = "1"
                e = "1"

                if self.height:
                        dim = 2
                        h = self.height

                if self.depth:
                        dim = 3
                        d = self.depth

                if self.extent:
                        dim = 4
                        e = self.extent

                return [ dim, w, h, d, e ]


        def get_stack_size(self):
                return self.type_expr.get_stack_size()


        def size(self):
                if self.is_image():
                        return 0
                else:
                        return self.type_expr.get_element_size()


        def get_element_count(self):
                c = self.type_expr.get_element_count()
                if c == 0:
                        return 1

                return c


        def size_string(self, use_parens = 1):
                s = self.size()
                if self.counter or self.count_parameter_list:
                        list = [ "compsize" ]

                        if self.counter and self.count_parameter_list:
                                list.append( self.counter )
                        elif self.counter:
                                list = [ self.counter ]

                        if s > 1:
                                list.append( str(s) )

                        if len(list) > 1 and use_parens :
                                return "(%s)" % (string.join(list, " * "))
                        else:
                                return string.join(list, " * ")

                elif self.is_image():
                        return "compsize"
                else:
                        return str(s)


        def format_string(self):
                if self.type_expr.original_string == "GLenum":
                        return "0x%x"
                else:
                        return self.type_expr.format_string()



class gl_function( gl_item ):
        def __init__(self, element, context):
                self.context = context
                self.name = None

                self.entry_points = []
                self.return_type = "void"
                self.parameters = []
                self.offset = -1
                self.uninitialized = 1
                self.images = []

                self.process_element( element )

                return

        
        def process_element(self, element):
                name = element.nsProp( "name", None )
                alias = element.nsProp( "alias", None )

                self.entry_points.append( name )
                if alias:
                        true_name = alias
                else:
                        true_name = name

                        # Only try to set the offset when a non-alias
                        # entry-point is being processes.

                        offset = element.nsProp( "offset", None )
                        if offset:
                                try:
                                        o = int( offset )
                                        self.offset = o
                                except Exception, e:
                                        self.offset = -1


                if not self.name:
                        self.name = true_name
                elif self.name != true_name:
                        raise RuntimeError("Function true name redefined.  Was %s, now %s." % (self.name, true_name))


                # There are two possible cases.  The first time an entry-point
                # with data is seen, self.uninitialzied will be 1.  On that
                # pass, we just fill in the data.  The next time an
                # entry-point with data is seen, self.uninitialized will be 0.
                # On that pass we have to make that the new values match the
                # valuse from the previous entry-point.

                child = element.children
                if self.uninitialized:
                        while child:
                                if child.type == "element":
                                        if child.name == "return":
                                                self.return_type = child.nsProp( "type", None )
                                        elif child.name == "param":
                                                param = self.context.factory.create_item( "parameter", child, self.context)
                                                self.parameters.append( param )

                                child = child.next
                else:
                        parameters = []
                        while child:
                                if child.type == "element":
                                        if child.name == "return":
                                                return_type = child.nsProp( "type", None )
                                                if self.return_type != return_type:
                                                        raise RuntimeError( "Return type changed in %s.  Was %s, now %s." % (name, self.return_type, return_type))
                                        elif child.name == "param":
                                                param = self.context.factory.create_item( "parameter", child, self.context)
                                                parameters.append( param )

                                child = child.next

                        if len(parameters) != len(self.parameters):
                                raise RuntimeError( "Parameter count mismatch in %s.  Was %d, now %d." % (name, len(self.parameters), len(parameters)))

                        for j in range(0, len(parameters)):
                                p1 = parameters[j]
                                p2 = self.parameters[j]
                                if not p1.compatible( p2 ):
                                        raise RuntimeError( 'Parameter type mismatch in %s.  "%s" was "%s", now "%s".' % (name, p2.name, p2.type_expr.original_string, p1.type_expr.original_string))


                        # This is done becuase we may hit an alias before we
                        # hit the "real" entry.  The aliases may not have all
                        # of the parameter information (e.g., counter,
                        # variable_param, etc. fields) required to generate
                        # GLX code.

                        if true_name == name:
                                self.parameters = parameters

                                for param in self.parameters:
                                        if param.is_image():
                                                self.images.append( param )

                if true_name == name:
                        for param in self.parameters:
                                if param.is_image():
                                        self.images.append( param )

                if element.children:
                        self.uninitialized = 0

                return


        def get_images(self):
                """Return potentially empty list of input images."""
                return self.images


        def parameterIterator(self):
                return self.parameters.__iter__();


        def get_parameter_string(self):
                list = []
                for p in self.parameters:
                        list.append( p.string() )

                if len(list) == 0:
                        return "void"
                else:
                        return string.join(list, ", ")


class gl_item_factory:
        """Factory to create objects derived from gl_item."""

        def create_item(self, item_name, element, context):
                if item_name == "function":
                        return gl_function(element, context)
                if item_name == "type":
                        return gl_type(element, context)
                elif item_name == "enum":
                        return gl_enum(element, context)
                elif item_name == "parameter":
                        return gl_parameter(element, context)
                elif item_name == "api":
                        return gl_api(self)
                else:
                        return None


class gl_api:
        def __init__(self, factory):
                self.functions_by_name = {}
                self.enums_by_name = {}
                self.types_by_name = {}
                self.category_dict = {}

                self.factory = factory

                typeexpr.create_initial_types()
                return


        def process_element(self, doc):
                element = doc.children
                while element.type != "element" or element.name != "OpenGLAPI":
                        element = element.next

                if element:
                        self.process_OpenGLAPI(element)
                return


        def process_OpenGLAPI(self, element):
                child = element.children
                while child:
                        if child.type == "element":
                                if child.name == "category":
                                        self.process_category( child )
                                elif child.name == "OpenGLAPI":
                                        self.process_OpenGLAPI( child )

                        child = child.next

                return


        def process_category(self, cat):
                cat_name = cat.nsProp( "name", None )
                cat_number = cat.nsProp( "number", None )

                child = cat.children
                while child:
                        if child.type == "element":
                                if child.name == "function":
                                        func_name = real_function_name( child )

                                        if self.functions_by_name.has_key( func_name ):
                                                func = self.functions_by_name[ func_name ]
                                                func.process_element( child )
                                        else:
                                                func = self.factory.create_item( "function", child, self )
                                                self.functions_by_name[ func_name ] = func

                                        if func_name == child.nsProp("name", None):
                                                self.category_dict[ func.name ] = [cat_name, cat_number]

                                elif child.name == "enum":
                                        enum = self.factory.create_item( "enum", child, self )
                                        self.enums_by_name[ enum.name ] = enum
                                elif child.name == "type":
                                        t = self.factory.create_item( "type", child, self )
                                        self.types_by_name[ "GL" + t.name ] = t


                        child = child.next

                return


        def functionIterateByOffset(self):
                max_offset = -1
                for func in self.functions_by_name.itervalues():
                        if func.offset > max_offset:
                                max_offset = func.offset


                temp = [None for i in range(0, max_offset + 1)]
                for func in self.functions_by_name.itervalues():
                        if func.offset != -1:
                                temp[ func.offset ] = func


                list = []
                for i in range(0, max_offset + 1):
                        if temp[i]:
                                list.append(temp[i])

                return list.__iter__();


        def functionIterateAll(self):
                return self.functions_by_name.itervalues()


        def enumIterateByName(self):
                keys = self.enums_by_name.keys()
                keys.sort()
                
                list = []
                for enum in keys:
                        list.append( self.enums_by_name[ enum ] )

                return list.__iter__()


        def get_category_for_name( self, name ):
                if self.category_dict.has_key(name):
                        return self.category_dict[name]
                else:
                        return ["<unknown category>", None]


        def typeIterate(self):
                return self.types_by_name.itervalues()


        def find_type( self, type_name ):
                if type_name in self.types_by_name:
                        return self.types_by_name[ type_name ].type_expr
                else:
                        print "Unable to find base type matching \"%s\"." % (type_name)
                        return None