# Copyright (C) 2012 Intel Corporation
#
# 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 (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 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.

# marshal_XML.py: factory for interpreting XML for the purpose of
# building thread marshalling code.

import gl_XML
import sys
import copy
import typeexpr

def pot_align(base, pot_alignment):
    return (base + pot_alignment - 1) & ~(pot_alignment - 1);


class marshal_item_factory(gl_XML.gl_item_factory):
    """Factory to create objects derived from gl_item containing
    information necessary to generate thread marshalling code."""

    def create_function(self, element, context):
        return marshal_function(element, context)


class marshal_function(gl_XML.gl_function):
    # We decrease the type size when it's safe, such as when the maximum value
    # and all greater values are invalid.
    def get_marshal_type(self, param):
        type = param.type_string()

        if ('Draw' in self.name and
            ('Arrays' in self.name or
             'Elements' in self.name or
             'TransformFeedback' in self.name)):
            if (type, param.name) == ('GLenum', 'mode'):
                return 'GLenum8'

            if (type, param.name) == ('GLenum', 'type'):
                return 'GLindextype'

        if type == 'GLenum':
            return 'GLenum16' # clamped to 0xffff (always invalid enum)

        if self.is_vertex_pointer_call:
            if (type, param.name) == ('GLsizei', 'stride'):
                return 'GLclamped16i'

            if (type, param.name) == ('GLint', 'size'):
                return 'GLpacked16i'

            # glVertexAttrib*Pointer(index)
            # glVertexArrayVertexBuffer(bindingindex)
            if ((type, param.name) == ('GLuint', 'index') or
                (type, param.name) == ('GLuint', 'bindingindex')):
                return 'GLenum8' # clamped to 0xff

        return type

    def get_type_size(self, param):
        type = self.get_marshal_type(param)

        if type.find('*') != -1:
            return 8;

        mapping = {
            'GLboolean': 1,
            'GLbyte': 1,
            'GLubyte': 1,
            'GLenum8': 1, # clamped by glthread
            'GLindextype': 1,
            'GLenum16': 2, # clamped by glthread
            'GLshort': 2,
            'GLushort': 2,
            'GLhalfNV': 2,
            'GLclamped16i': 2, # clamped by glthread
            'GLpacked16i': 2, # clamped by glthread
            'GLint': 4,
            'GLuint': 4,
            'GLbitfield': 4,
            'GLsizei': 4,
            'GLfloat': 4,
            'GLclampf': 4,
            'GLfixed': 4,
            'GLclampx': 4,
            'GLhandleARB': 4,
            'int': 4,
            'float': 4,
            'GLintptr': self.context.pointer_size,
            'GLsizeiptr': self.context.pointer_size,
            'GLsync': self.context.pointer_size,
            'GLDEBUGPROC': self.context.pointer_size,
            'GLdouble': 8,
            'GLclampd': 8,
            'GLint64': 8,
            'GLuint64': 8,
            'GLuint64EXT': 8,
        }
        val = mapping.get(type, 9999)
        if val == 9999:
            print('Unhandled type in marshal_XML.get_type_size: "{0}"'.format(type), file=sys.stderr)
            assert False
        return val

    def process_element(self, element):
        # Do normal processing.
        super(marshal_function, self).process_element(element)

        # Only do further processing when we see the canonical
        # function name.
        if element.get('name') != self.name:
            return

        # Classify fixed and variable parameters.
        self.fixed_params = []
        self.variable_params = []
        for p in self.parameters:
            if p.is_padding:
                continue
            if p.is_variable_length():
                self.variable_params.append(p)
            else:
                self.fixed_params.append(p)

        # Store the "marshal" attribute, if present.
        self.marshal = element.get('marshal')
        self.marshal_sync = element.get('marshal_sync')
        self.marshal_call_before = element.get('marshal_call_before')
        self.marshal_call_after = element.get('marshal_call_after')
        self.marshal_struct = element.get('marshal_struct')
        self.marshal_no_error = gl_XML.is_attr_true(element, 'marshal_no_error')
        self.is_vertex_pointer_call = (self.name == 'InterleavedArrays' or
                                       self.name.endswith('VertexBuffer') or
                                       self.name.endswith('VertexBufferEXT') or
                                       self.name.endswith('Pointer') or
                                       self.name.endswith('PointerEXT') or
                                       self.name.endswith('PointerOES') or
                                       self.name.endswith('OffsetEXT'))

        # marshal_sync means whether a function should be called to determine
        # whether we should sync.
        if self.marshal_sync:
            # This is a case of a pointer with an unknown size. Move
            # variable-sized pointer parameters to fixed parameters because
            # they will be passed as-is if the marshal_sync function evaluates
            # to true.
            self.fixed_params = self.fixed_params + self.variable_params
            self.variable_params = []

        # Sort the parameters, so that the marshal structure fields are sorted
        # from smallest to biggest.
        self.fixed_params = sorted(self.fixed_params, key=lambda p: self.get_type_size(p))

        # Compute the marshal structure size and the largest hole
        self.struct_size = 2 # sizeof(struct marshal_cmd_base)
        largest_hole = 0

        for p in self.fixed_params:
            type_size = self.get_type_size(p)
            aligned_size = pot_align(self.struct_size, type_size)
            largest_hole = max(aligned_size - self.struct_size, largest_hole)
            self.struct_size = aligned_size
            self.struct_size = self.struct_size + type_size

        # Round down largest_hole to a power of two.
        largest_hole = int(2 ** (largest_hole.bit_length() - 1))

        # Align the structure to 8 bytes.
        aligned_size = pot_align(self.struct_size, 8)
        padding_hole = aligned_size - self.struct_size
        self.struct_size = aligned_size

        # Determine whether to generate a packed version of gl*Pointer calls.
        # If there is a hole in the cmd structure, the pointer/offset parameter
        # can be truncated and stored in the hole to save 8 bytes per call.
        # The version of the structure is determined at runtime based on
        # whether the truncation doesn't change the value. This is common with
        # VBOs because the pointer/offset is usually small.
        #
        # If there is no hole, the packed version completely removes
        # the pointer/offset parameter and is used when the value is NULL/0
        # to remove 8 bytes per call. This is common with VBOs.
        self.packed_param_name = None

        if (self.is_vertex_pointer_call and
            # 32-bit CPUs only benefit if we remove the whole 8-byte slot,
            # which means there must be exactly 4-byte padding after the 4-byte
            # pointer/offset parameter.
            (self.context.pointer_size != 4 or padding_hole == 4)):
            for pname in ['pointer', 'offset']:
                if pname in [p.name for p in self.fixed_params]:
                    self.packed_param_name = pname

            assert self.packed_param_name
            assert not self.variable_params
            assert not self.marshal_sync

        # Prepare the parameters for the packed version by replacing the type
        # of the packed variable or removing it completely.
        self.packed_fixed_params = []
        if self.packed_param_name:
            for p in self.fixed_params:
                if p.name == self.packed_param_name:
                    if largest_hole > 0:
                        # Select the truncated type.
                        type = ['GLubyte', 'GLushort', 'GLuint'][largest_hole.bit_length() - 1]

                        # Clone the parameter and change its type
                        new_param = copy.deepcopy(p)
                        new_param.type_expr = typeexpr.type_expression(type, self.context)
                        self.packed_fixed_params.append(new_param)
                else:
                    self.packed_fixed_params.append(p)
            self.packed_param_size = largest_hole
        # Sort the parameters by size to move the truncated type into the hole.
        self.packed_fixed_params = sorted(self.packed_fixed_params, key=lambda p: self.get_type_size(p))


    def get_fixed_params(self, is_packed):
        return self.packed_fixed_params if is_packed else self.fixed_params

    def marshal_flavor(self):
        """Find out how this function should be marshalled between
        client and server threads."""
        # If a "marshal" attribute was present, that overrides any
        # determination that would otherwise be made by this function.
        if self.marshal is not None:
            return self.marshal

        if self.exec_flavor == 'skip':
            # Functions marked exec="skip" are not yet implemented in
            # Mesa, so don't bother trying to marshal them.
            return 'skip'

        if self.return_type != 'void':
            return 'sync'
        for p in self.parameters:
            if p.is_output:
                return 'sync'
            if (p.is_pointer() and not
                (p.count or p.counter or p.marshal_count or p.marshal_large_count)):
                return 'sync'
            if p.count_parameter_list and not (p.marshal_count or p.marshal_large_count):
                # Parameter size is determined by enums; haven't
                # written logic to handle this yet.  TODO: fix.
                return 'sync'
        return 'async'

    def marshal_is_static(self):
        return (self.marshal_flavor() != 'custom' and
                self.name[0:8] != 'Internal' and
                self.exec_flavor != 'beginend')

    def print_struct(self, is_header=False, is_packed=False):
        if (self.marshal_struct == 'public') == is_header:
            print(self.get_marshal_struct_name(is_packed))
            print('{')
            print('   struct marshal_cmd_base cmd_base;')
            if self.variable_params:
                print('   uint16_t num_slots;')

            for p in self.get_fixed_params(is_packed):
                if p.count:
                    print('   {0} {1}[{2}];'.format(
                            p.get_base_type_string(), p.name, p.count))
                else:
                    print('   {0} {1};'.format(self.get_marshal_type(p), p.name))

            for p in self.variable_params:
                if p.img_null_flag:
                    print('   bool {0}_null; /* If set, no data follows '
                        'for "{0}" */'.format(p.name))

            for p in self.variable_params:
                if p.count_scale != 1:
                    print(('   /* Next {0} bytes are '
                         '{1} {2}[{3}][{4}] */').format(
                            p.size_string(marshal=1), p.get_base_type_string(),
                            p.name, p.counter, p.count_scale))
                else:
                    print(('   /* Next {0} bytes are '
                         '{1} {2}[{3}] */').format(
                            p.size_string(marshal=1), p.get_base_type_string(),
                            p.name, p.counter))
            print('};')
        elif self.marshal_flavor() in ('custom', 'async'):
            print('{0};'.format(self.get_marshal_struct_name(is_packed)))

        if not is_packed and self.packed_fixed_params:
            self.print_struct(is_header, True)

    def get_marshal_struct_name(self, is_packed=False):
        return 'struct marshal_cmd_{0}{1}'.format(self.name, '_packed' if is_packed else '')

    def print_unmarshal_prototype(self, is_packed=False, suffix=''):
        print(('uint32_t _mesa_unmarshal_{0}{1}(struct gl_context *ctx, '
               'const {2} *restrict cmd){3}')
               .format(self.name, '_packed' if is_packed else '',
                       self.get_marshal_struct_name(is_packed), suffix))