Subversion Repositories Kolibri OS

#!/usr/bin/python

#

# Copyright (C) 2009 Chia-I Wu 

#

# 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.

"""

Minimal apiutil.py interface for use by es_generator.py.

"""

import sys

import libxml2

import APIspec

__spec = {}

__functions = {}

__aliases = {}

def _ParseXML(filename, apiname):

    conversions = {

        # from           to

        'GLfloat':  [ 'GLdouble' ],

        'GLclampf': [ 'GLclampd' ],

        'GLubyte':  [ 'GLfloat', 'GLdouble' ],

        'GLint':    [ 'GLfloat', 'GLdouble' ],

        'GLfixed':  [ 'GLfloat', 'GLdouble' ],

        'GLclampx': [ 'GLclampf', 'GLclampd' ],

    }

    doc = libxml2.readFile(filename, None,

            libxml2.XML_PARSE_DTDLOAD +

            libxml2.XML_PARSE_DTDVALID +

            libxml2.XML_PARSE_NOBLANKS)

    spec = APIspec.Spec(doc)

    impl = spec.get_impl()

    api = spec.get_api(apiname)

    doc.freeDoc()

    __spec["impl"] = impl

    __spec["api"] = api

    for func in api.functions:

        alias, need_conv = impl.match(func, conversions)

        if not alias:

            # external functions are manually dispatched

            if not func.is_external:

                print >>sys.stderr, "Error: unable to dispatch %s" % func.name

            alias = func

            need_conv = False

        __functions[func.name] = func

        __aliases[func.name] = (alias, need_conv)

def AllSpecials(notused=None):

    """Return a list of all external functions in the API."""

    api = __spec["api"]

    specials = []

    for func in api.functions:

        if func.is_external:

            specials.append(func.name)

    return specials

def GetAllFunctions(filename, api):

    """Return sorted list of all functions in the API."""

    if not __spec:

        _ParseXML(filename, api)

    api = __spec["api"]

    names = []

    for func in api.functions:

        names.append(func.name)

    names.sort()

    return names

def ReturnType(funcname):

    """Return the C return type of named function."""

    func = __functions[funcname]

    return func.return_type

def Properties(funcname):

    """Return list of properties of the named GL function."""

    func = __functions[funcname]

    return [func.direction]

def _ValidValues(func, param):

    """Return the valid values of a parameter."""

    valid_values = []

    switch = func.checker.switches.get(param.name, [])

    for desc in switch:

        # no dependent vector

        if not desc.checker.switches:

            for val in desc.values:

                valid_values.append((val, None, None, [], desc.error, None))

            continue

        items = desc.checker.switches.items()

        if len(items) > 1:

            print >>sys.stderr, "%s: more than one parameter depend on %s" % \

                    (func.name, desc.name)

        dep_name, dep_switch = items[0]

        for dep_desc in dep_switch:

            if dep_desc.index >= 0 and dep_desc.index != 0:

                print >>sys.stderr, "%s: not first element of a vector" % func.name

            if dep_desc.checker.switches:

                print >>sys.stderr, "%s: deep nested dependence" % func.name

            convert = None if dep_desc.convert else "noconvert"

            for val in desc.values:

                valid_values.append((val, dep_desc.size_str, dep_desc.name,

                                     dep_desc.values, dep_desc.error, convert))

    return valid_values

def _Conversion(func, src_param):

    """Return the destination type of the conversion, or None."""

    alias, need_conv = __aliases[func.name]

    if need_conv:

        dst_param = alias.get_param(src_param.name)

        if src_param.type == dst_param.type:

            need_conv = False

    if not need_conv:

        return (None, "none")

    converts = { True: 0, False: 0 }

    # In Fogx, for example,  pname may be GL_FOG_DENSITY/GL_FOG_START/GL_FOG_END

    # or GL_FOG_MODE.  In the former three cases, param is not checked and the

    # default is to convert.

    if not func.checker.always_check(src_param.name):

        converts[True] += 1

    for desc in func.checker.flatten(src_param.name):

        converts[desc.convert] += 1

        if converts[True] and converts[False]:

            break

    # it should be "never", "sometimes", and "always"...

    if converts[False]:

        if converts[True]:

            conversion = "some"

        else:

            conversion = "none"

    else:

        conversion = "all"

    return (dst_param.base_type(), conversion)

def _MaxVecSize(func, param):

    """Return the largest possible size of a vector."""

    if not param.is_vector:

        return 0

    if param.size:

        return param.size

    # need to look at all descriptions

    size = 0

    for desc in func.checker.flatten(param.name):

        if desc.size_str and desc.size_str.isdigit():

            s = int(desc.size_str)

            if s > size:

                size = s

    if not size:

        need_conv = __aliases[func.name][1]

        if need_conv:

            print >>sys.stderr, \

                    "Error: unable to dicide the max size of %s in %s" % \

                    (param.name, func.name)

    return size

def _ParameterTuple(func, param):

    """Return a parameter tuple.

    [0] -- parameter name

    [1] -- parameter type

    [2] -- max vector size or 0

    [3] -- dest type the parameter converts to, or None

    [4] -- valid values

    [5] -- how often does the conversion happen

    """

    vec_size = _MaxVecSize(func, param)

    dst_type, conversion = _Conversion(func, param)

    valid_values = _ValidValues(func, param)

    return (param.name, param.type, vec_size, dst_type, valid_values, conversion)

def Parameters(funcname):

    """Return list of tuples of function parameters."""

    func = __functions[funcname]

    params = []

    for param in func.params:

        params.append(_ParameterTuple(func, param))

    return params

def FunctionPrefix(funcname):

    """Return function specific prefix."""

    func = __functions[funcname]

    return func.prefix

def FindParamIndex(params, paramname):

    """Find the index of a named parameter."""

    for i in xrange(len(params)):

        if params[i][0] == paramname:

            return i

    return None

def MakeDeclarationString(params):

    """Return a C-style parameter declaration string."""

    string = []

    for p in params:

        sep = "" if p[1].endswith("*") else " "

        string.append("%s%s%s" % (p[1], sep, p[0]))

    if not string:

        return "void"

    return ", ".join(string)

def AliasPrefix(funcname):

    """Return the prefix of the function the named function is an alias of."""

    alias = __aliases[funcname][0]

    return alias.prefix

def Alias(funcname):

    """Return the name of the function the named function is an alias of."""

    alias, need_conv = __aliases[funcname]

    return alias.name if not need_conv else None

def ConversionFunction(funcname):

    """Return the name of the function the named function converts to."""

    alias, need_conv = __aliases[funcname]

    return alias.name if need_conv else None

def Categories(funcname):

    """Return all the categories of the named GL function."""

    api = __spec["api"]

    return [api.name]