#!/usr/bin/env python

from __future__ import print_function

import getopt

import os

import sys

import errno

import re

# Jump to the bottom of this file for the main routine

#config settings (can be changed with commandline options)

config_server_side = False

# Some hacks to make the API more readable, and to keep backwards compability

_cname_re = re.compile('([A-Z0-9][a-z]+|[A-Z0-9]+(?![a-z])|[a-z]+)')

_cname_special_cases = {'DECnet':'decnet'}

_extension_special_cases = ['XPrint', 'XCMisc', 'BigRequests']

_cplusplus_annoyances = {'class' : '_class',

                         'new'   : '_new',

                         'delete': '_delete'}

_c_keywords = {'default' : '_default'}

_hlines = []

_hlevel = 0

_clines = []

_clevel = 0

_ns = None

# global variable to keep track of serializers and

# switch data types due to weird dependencies

finished_serializers = []

finished_sizeof = []

finished_switch = []

# keeps enum objects so that we can refer to them when generating manpages.

enums = {}

manpaths = False

def _h(fmt, *args):

    '''

    Writes the given line to the header file.

    '''

    _hlines[_hlevel].append(fmt % args)

def _c(fmt, *args):

    '''

    Writes the given line to the source file.

    '''

    _clines[_clevel].append(fmt % args)

def _hc(fmt, *args):

    '''

    Writes the given line to both the header and source files.

    '''

    _h(fmt, *args)

    _c(fmt, *args)

def _c_wr_stringlist(indent, strlist):

    '''

    Writes the given list of strings to the source file.

    Each line is prepended by the indent string

    '''

    for str in strlist:

        _c("%s%s", indent, str)

class PreCode(object):

    '''

    For pre-code generated by expression generation

    (for example, the for-loop of a sumof)

    This has to account for recursiveness of the expression

    generation, i.e., there may be pre-code for pre-code.

    Therefore this is implemented as a stack of lists of lines.

    If redirection is switched on, then all output is collected in

    self.redirect_code and self.redirect_tempvars instead of

    being sent to the output via _h und _c.

    '''

    def __init__(self):

        self.nesting_level = 0

        self.tempvars = []

        self.codelines = []

        self.redirect_code = None

        self.redirect_tempvars = None

        self.indent_str = '    '

        self.indent_stack = []

        self.tempvar_num = 0

    # start and end of pre-code blocks

    def start(self):

        self.nesting_level += 1

    def end(self):

        self.nesting_level -= 1

        if self.nesting_level == 0:

            # lowest pre-code level is finished -> output to source

            if self.redirect_tempvars is None:

                _c_wr_stringlist('', self.tempvars)

                self.tempvars = []

            else:

                self.redirect_tempvars.extend(self.tempvars)

                self.tempvars = []

            if self.redirect_code == None:

                _c_wr_stringlist('', self.codelines)

                self.codelines = []

            else:

                self.redirect_code.extend(self.codelines)

                self.codelines = []

    def output_tempvars(self):

        if self.redirect_code == None:

            _c_wr_stringlist('', self.tempvars)

            self.tempvars = []

    # output to precode

    def code(self, fmt, *args):

        self.codelines.append(self.indent_str + fmt % args)

    def tempvar(self, fmt, *args):

        self.tempvars.append('    ' + (fmt % args))

    # get a unique name for a temporary variable

    def get_tempvarname(self):

        self.tempvar_num += 1

        return "xcb_pre_tmp_%d" % self.tempvar_num

    # indentation

    def push_indent(self, indentstr):

        self.indent_stack.append(self.indent_str)

        self.indent_str = indentstr

    def push_addindent(self, indent_add_str):

        self.push_indent(self.indent_str + indent_add_str)

    def indent(self):

        self.push_addindent('    ')

    def pop_indent(self):

        self.indent_str = self.indent_stack.pop()

    # redirection to lists

    def redirect_start(self, redirect_code, redirect_tempvars=None):

        self.redirect_code = redirect_code

        self.redirect_tempvars = redirect_tempvars

        if redirect_tempvars is not None:

            self.tempvar_num = 0

    def redirect_end(self):

        self.redirect_code = None

        self.redirect_tempvars = None

# global PreCode handler

_c_pre = PreCode()

# XXX See if this level thing is really necessary.

def _h_setlevel(idx):

    '''

    Changes the array that header lines are written to.

    Supports writing different sections of the header file.

    '''

    global _hlevel

    while len(_hlines) <= idx:

        _hlines.append([])

    _hlevel = idx

def _c_setlevel(idx):

    '''

    Changes the array that source lines are written to.

    Supports writing to different sections of the source file.

    '''

    global _clevel

    while len(_clines) <= idx:

        _clines.append([])

    _clevel = idx

def _n_item(str):

    '''

    Does C-name conversion on a single string fragment.

    Uses a regexp with some hard-coded special cases.

    '''

    if str in _cname_special_cases:

        return _cname_special_cases[str]

    else:

        split = _cname_re.finditer(str)

        name_parts = [match.group(0) for match in split]

        return '_'.join(name_parts)

def _cpp(str):

    '''

    Checks for certain C++ reserved words and fixes them.

    '''

    if str in _cplusplus_annoyances:

        return _cplusplus_annoyances[str]

    elif str in _c_keywords:

        return  _c_keywords[str]

    else:

        return str

def _ext(str):

    '''

    Does C-name conversion on an extension name.

    Has some additional special cases on top of _n_item.

    '''

    if str in _extension_special_cases:

        return _n_item(str).lower()

    else:

        return str.lower()

def _n(list):

    '''

    Does C-name conversion on a tuple of strings.

    Different behavior depending on length of tuple, extension/not extension, etc.

    Basically C-name converts the individual pieces, then joins with underscores.

    '''

    if len(list) == 1:

        parts = list

    elif len(list) == 2:

        parts = [list[0], _n_item(list[1])]

    elif _ns.is_ext:

        parts = [list[0], _ext(list[1])] + [_n_item(i) for i in list[2:]]

    else:

        parts = [list[0]] + [_n_item(i) for i in list[1:]]

    return '_'.join(parts).lower()

def _t(list):

    '''

    Does C-name conversion on a tuple of strings representing a type.

    Same as _n but adds a "_t" on the end.

    '''

    if len(list) == 1:

        parts = list

    elif len(list) == 2:

        parts = [list[0], _n_item(list[1]), 't']

    elif _ns.is_ext:

        parts = [list[0], _ext(list[1])] + [_n_item(i) for i in list[2:]] + ['t']

    else:

        parts = [list[0]] + [_n_item(i) for i in list[1:]] + ['t']

    return '_'.join(parts).lower()

def c_open(self):

    '''

    Exported function that handles module open.

    Opens the files and writes out the auto-generated comment, header file includes, etc.

    '''

    global _ns

    _ns = self.namespace

    _ns.c_ext_global_name = _n(_ns.prefix + ('id',))

    # Build the type-name collision avoidance table used by c_enum

    build_collision_table()

    _h_setlevel(0)

    _c_setlevel(0)

    _hc('/*')

    _hc(' * This file generated automatically from %s by c_client.py.', _ns.file)

    _hc(' * Edit at your peril.')

    _hc(' */')

    _hc('')

    _h('/**')

    _h(' * @defgroup XCB_%s_API XCB %s API', _ns.ext_name, _ns.ext_name)

    _h(' * @brief %s XCB Protocol Implementation.', _ns.ext_name)

    _h(' * @{')

    _h(' **/')

    _h('')

    _h('#ifndef __%s_H', _ns.header.upper())

    _h('#define __%s_H', _ns.header.upper())

    _h('')

    _h('#include "xcb.h"')

    _c('#ifdef HAVE_CONFIG_H')

    _c('#include "config.h"')

    _c('#endif')

    _c('#include <stdlib.h>')

    _c('#include <string.h>')

    _c('#include <assert.h>')

    _c('#include <stddef.h>  /* for offsetof() */')

    _c('#include "xcbext.h"')

    _c('#include "%s.h"', _ns.header)

    _c('')

    _c('#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member)')

    if _ns.is_ext:

        for (n, h) in self.direct_imports:

            _hc('#include "%s.h"', h)

    _h('')

    _h('#ifdef __cplusplus')

    _h('extern "C" {')

    _h('#endif')

    if _ns.is_ext:

        _h('')

        _h('#define XCB_%s_MAJOR_VERSION %s', _ns.ext_name.upper(), _ns.major_version)

        _h('#define XCB_%s_MINOR_VERSION %s', _ns.ext_name.upper(), _ns.minor_version)

        _h('') #XXX

        _h('extern xcb_extension_t %s;', _ns.c_ext_global_name)

        _c('')

        _c('xcb_extension_t %s = { "%s", 0 };', _ns.c_ext_global_name, _ns.ext_xname)

def c_close(self):

    '''

    Exported function that handles module close.

    Writes out all the stored content lines, then closes the files.

    '''

    _h_setlevel(2)

    _c_setlevel(2)

    _hc('')

    _h('')

    _h('#ifdef __cplusplus')

    _h('}')

    _h('#endif')

    _h('')

    _h('#endif')

    _h('')

    _h('/**')

    _h(' * @}')

    _h(' */')

    # Write header file

    hfile = open('%s.h' % _ns.header, 'w')

    for list in _hlines:

        for line in list:

            hfile.write(line)

            hfile.write('\n')

    hfile.close()

    # Write source file

    cfile = open('%s.c' % _ns.header, 'w')

    for list in _clines:

        for line in list:

            cfile.write(line)

            cfile.write('\n')

    cfile.close()

def build_collision_table():

    global namecount

    namecount = {}

    for v in module.types.values():

        name = _t(v[0])

        namecount[name] = (namecount.get(name) or 0) + 1

def c_enum(self, name):

    '''

    Exported function that handles enum declarations.

    '''

    enums[name] = self

    tname = _t(name)

    if namecount[tname] > 1:

        tname = _t(name + ('enum',))

    _h_setlevel(0)

    _h('')

    _h('typedef enum %s {', tname)

    count = len(self.values)

    for (enam, eval) in self.values:

        count = count - 1

        equals = ' = ' if eval != '' else ''

        comma = ',' if count > 0 else ''

        doc = ''

        if hasattr(self, "doc") and self.doc and enam in self.doc.fields:

            doc = '\n/**< %s */\n' % self.doc.fields[enam]

        _h('    %s%s%s%s%s', _n(name + (enam,)).upper(), equals, eval, comma, doc)

    _h('} %s;', tname)

def _c_type_setup(self, name, postfix):

    '''

    Sets up all the C-related state by adding additional data fields to

    all Field and Type objects.  Here is where we figure out most of our

    variable and function names.

    Recurses into child fields and list member types.

    '''

    # Do all the various names in advance

    self.c_type = _t(name + postfix)

    self.c_wiretype = 'char' if self.c_type == 'void' else self.c_type

    self.c_iterator_type = _t(name + ('iterator',))

    self.c_next_name = _n(name + ('next',))

    self.c_end_name = _n(name + ('end',))

    self.c_request_name = _n(name)

    self.c_checked_name = _n(name + ('checked',))

    self.c_unchecked_name = _n(name + ('unchecked',))

    self.c_reply_name = _n(name + ('reply',))

    self.c_reply_type = _t(name + ('reply',))

    self.c_cookie_type = _t(name + ('cookie',))

    self.c_reply_fds_name = _n(name + ('reply_fds',))

    self.c_need_aux = False

    self.c_need_serialize = False

    self.c_need_sizeof = False

    self.c_aux_name = _n(name + ('aux',))

    self.c_aux_checked_name = _n(name + ('aux', 'checked'))

    self.c_aux_unchecked_name = _n(name + ('aux', 'unchecked'))

    self.c_serialize_name = _n(name + ('serialize',))

    self.c_unserialize_name = _n(name + ('unserialize',))

    self.c_unpack_name = _n(name + ('unpack',))

    self.c_sizeof_name = _n(name + ('sizeof',))

    # special case: structs where variable size fields are followed by fixed size fields

    self.c_var_followed_by_fixed_fields = False

    if self.is_switch:

        self.c_need_serialize = True

        self.c_container = 'struct'

        for bitcase in self.bitcases:

            bitcase.c_field_name = _cpp(bitcase.field_name)

            bitcase_name = bitcase.field_type if bitcase.type.has_name else name

            _c_type_setup(bitcase.type, bitcase_name, ())

    elif self.is_container:

        self.c_container = 'union' if self.is_union else 'struct'

        prev_varsized_field = None

        prev_varsized_offset = 0

        first_field_after_varsized = None

        for field in self.fields:

            if field.type.is_event:

                field.c_field_type = _t(field.field_type + ('event',))

            else:

                field.c_field_type = _t(field.field_type)

            field.c_field_const_type = ('' if field.type.nmemb == 1 else 'const ') + field.c_field_type

            field.c_field_name = _cpp(field.field_name)

            field.c_subscript = '[%d]' % field.type.nmemb if (field.type.nmemb and field.type.nmemb > 1) else ''

            field.c_pointer = ' ' if field.type.nmemb == 1 else '*'

            # correct the c_pointer field for variable size non-list types

            if not field.type.fixed_size() and field.c_pointer == ' ':

                field.c_pointer = '*'

            if field.type.is_list and not field.type.member.fixed_size():

                field.c_pointer = '*'

            if field.type.is_switch:

                field.c_pointer = '*'

                field.c_field_const_type = 'const ' + field.c_field_type

                self.c_need_aux = True

            if not field.type.fixed_size() and not field.type.is_case_or_bitcase and field.wire:

                self.c_need_sizeof = True

            field.c_iterator_type = _t(field.field_type + ('iterator',))      # xcb_fieldtype_iterator_t

            field.c_iterator_name = _n(name + (field.field_name, 'iterator')) # xcb_container_field_iterator

            field.c_accessor_name = _n(name + (field.field_name,))            # xcb_container_field

            field.c_length_name = _n(name + (field.field_name, 'length'))     # xcb_container_field_length

            field.c_end_name = _n(name + (field.field_name, 'end'))           # xcb_container_field_end

            field.prev_varsized_field = prev_varsized_field

            field.prev_varsized_offset = prev_varsized_offset

            if prev_varsized_offset == 0:

                first_field_after_varsized = field

            field.first_field_after_varsized = first_field_after_varsized

            if field.type.fixed_size():

                if field.wire:

                    prev_varsized_offset += field.type.size

                # special case: intermixed fixed and variable size fields

                if prev_varsized_field is not None and not field.type.is_pad and field.wire:

                    if not self.is_union:

                        self.c_need_serialize = True

                        self.c_var_followed_by_fixed_fields = True

            else:

                self.last_varsized_field = field

                prev_varsized_field = field

                prev_varsized_offset = 0

            if self.c_var_followed_by_fixed_fields:

                if field.type.fixed_size():

                    field.prev_varsized_field = None

            # recurse into this field this has to be done here, i.e.,

            # after the field has been set up. Otherwise the function

            # _c_helper_fieldaccess_expr will produce garbage or crash

            _c_type_setup(field.type, field.field_type, ())

            if field.type.is_list:

                _c_type_setup(field.type.member, field.field_type, ())

                if (field.type.nmemb is None and field.wire):

                    self.c_need_sizeof = True

    if self.c_need_serialize:

        # when _unserialize() is wanted, create _sizeof() as well for consistency reasons

        self.c_need_sizeof = True

    # as switch does never appear at toplevel,

    # continue here with type construction

    if self.is_switch:

        if self.c_type not in finished_switch:

            finished_switch.append(self.c_type)

            # special: switch C structs get pointer fields for variable-sized members

            _c_complex(self)

            for bitcase in self.bitcases:

                bitcase_name = bitcase.type.name if bitcase.type.has_name else name

                _c_accessors(bitcase.type, bitcase_name, bitcase_name)

                # no list with switch as element, so no call to

                # _c_iterator(field.type, field_name) necessary

    if not self.is_case_or_bitcase:

        if self.c_need_serialize:

            if self.c_serialize_name not in finished_serializers:

                finished_serializers.append(self.c_serialize_name)

                _c_serialize('serialize', self)

                # _unpack() and _unserialize() are only needed for special cases:

                #   switch -> unpack

                #   special cases -> unserialize

                if self.is_switch or self.c_var_followed_by_fixed_fields:

                    _c_serialize('unserialize', self)

        if self.c_need_sizeof:

            if self.c_sizeof_name not in finished_sizeof:

                if not module.namespace.is_ext or self.name[:2] == module.namespace.prefix:

                    finished_sizeof.append(self.c_sizeof_name)

                    _c_serialize('sizeof', self)

# Functions for querying field properties

def _c_field_needs_list_accessor(field):

    return field.type.is_list and not field.type.fixed_size()

def _c_field_needs_field_accessor(field):

    if field.type.is_list:

        return False

    else:

        return (field.prev_varsized_field is not None or

                not field.type.fixed_size())

def _c_field_needs_accessor(field):

    return (_c_field_needs_list_accessor(field) or

            _c_field_needs_field_accessor(field))

def _c_field_is_member_of_case_or_bitcase(field):

    return field.parent and field.parent.is_case_or_bitcase

def _c_helper_fieldaccess_expr(prefix, field=None):

    """

    turn prefix, which is a list of tuples (name, separator, Type obj) into a string

    representing a valid field-access-expression in C (based on the context)

    if field is not None, append access to the field as well.

    "separator" is one of the C-operators "." or "->".

    A field access expression can consist of the following components:

    * struct/union member access from a value with the "."-operator

    * struct/union member access from a pointer with "->"-operator

    * function-call of an accessor function:

      This is used when a xcb-field is not contained in a struct.

      This can, e.g., happen for fields after var-sized fields, etc.

    """

    prefix_str = ''

    last_sep =''

    for name, sep, obj in prefix:

        prefix_str += last_sep + name

        last_sep = sep

    if field is None:

        # add separator for access to a yet unknown field

        prefix_str += last_sep

    else:

        if _c_field_needs_accessor(field):

            if _c_field_is_member_of_case_or_bitcase(field):

                # case members are available in the deserialized struct,

                # so there is no need to use the accessor function

                # (also, their accessor function needs a different arglist

                # so this would require special treatment here)

                # Therefore: Access as struct member

                prefix_str += last_sep + _cpp(field.field_name)

            else:

                # Access with the accessor function

                prefix_str = field.c_accessor_name + "(" + prefix_str + ")"

        else:

            # Access as struct member

            prefix_str += last_sep + _cpp(field.field_name)

    return prefix_str

def _c_helper_field_mapping(complex_type, prefix, flat=False):

    """

    generate absolute names, based on prefix, for all fields starting from complex_type

    if flat == True, nested complex types are not taken into account

    """

    all_fields = {}

    if complex_type.is_switch:

        for b in complex_type.bitcases:

            if b.type.has_name:

                switch_name, switch_sep, switch_type = prefix[-1]

                bitcase_prefix = prefix + [(b.type.name[-1], '.', b.type)]

            else:

                bitcase_prefix = prefix

            if (flat and not b.type.has_name) or not flat:

                all_fields.update(_c_helper_field_mapping(b.type, bitcase_prefix, flat))

    else:

        for f in complex_type.fields:

            fname = _c_helper_fieldaccess_expr(prefix, f)

            if f.field_name in all_fields:

                raise Exception("field name %s has been registered before" % f.field_name)

            all_fields[f.field_name] = (fname, f)

            if f.type.is_container and not flat:

                if f.type.is_case_or_bitcase and not f.type.has_name:

                    new_prefix = prefix

                elif f.type.is_switch and len(f.type.parents)>1:

                    # nested switch gets another separator

                    new_prefix = prefix+[(f.c_field_name, '.', f.type)]

                else:

                    new_prefix = prefix+[(f.c_field_name, '->', f.type)]

                all_fields.update(_c_helper_field_mapping(f.type, new_prefix, flat))

    return all_fields

def _c_helper_resolve_field_names (prefix):

    """

    get field names for all objects in the prefix array

    """

    all_fields = {}

    tmp_prefix = []

    # look for fields in the remaining containers

    for idx, (name, sep, obj) in enumerate(prefix):

        if ''==sep:

            # sep can be preset in prefix, if not, make a sensible guess

            sep = '.' if (obj.is_switch or obj.is_case_or_bitcase) else '->'

            # exception: 'toplevel' object (switch as well!) always have sep '->'

            sep = '->' if idx<1 else sep

        if not obj.is_case_or_bitcase or (obj.is_case_or_bitcase and obj.has_name):

            tmp_prefix.append((name, sep, obj))

        all_fields.update(_c_helper_field_mapping(obj, tmp_prefix, flat=True))

    return all_fields

def get_expr_fields(self):

    """

    get the Fields referenced by switch or list expression

    """

    def get_expr_field_names(expr):

        if expr.op is None or expr.op == 'calculate_len':

            if expr.lenfield_name is not None:

                return [expr.lenfield_name]

            else:

                # constant value expr

                return []

        else:

            if expr.op == '~':

                return get_expr_field_names(expr.rhs)

            elif expr.op == 'popcount':

                return get_expr_field_names(expr.rhs)

            elif expr.op == 'sumof':

                # sumof expr references another list,

                # we need that list's length field here

                field = None

                for f in expr.lenfield_parent.fields:

                    if f.field_name == expr.lenfield_name:

                        field = f

                        break

                if field is None:

                    raise Exception("list field '%s' referenced by sumof not found" % expr.lenfield_name)

                # referenced list + its length field

                return [expr.lenfield_name] + get_expr_field_names(field.type.expr)

            elif expr.op == 'enumref':

                return []

            else:

                return get_expr_field_names(expr.lhs) + get_expr_field_names(expr.rhs)

    # get_expr_field_names()

    # resolve the field names with the parent structure(s)

    unresolved_fields_names = get_expr_field_names(self.expr)

    # construct prefix from self

    prefix = [('', '', p) for p in self.parents]

    if self.is_container:

        prefix.append(('', '', self))

    all_fields = _c_helper_resolve_field_names (prefix)

    resolved_fields_names = [x for x in unresolved_fields_names if x in all_fields]

    if len(unresolved_fields_names) != len(resolved_fields_names):

        raise Exception("could not resolve all fields for %s" % self.name)

    resolved_fields = [all_fields[n][1] for n in resolved_fields_names]

    return resolved_fields

def resolve_expr_fields(complex_obj):

    """

    find expr fields appearing in complex_obj and descendents that cannot be resolved within complex_obj

    these are normally fields that need to be given as function parameters

    """

    all_fields = []

    expr_fields = []

    unresolved = []

    for field in complex_obj.fields:

        all_fields.append(field)

        if field.type.is_switch or field.type.is_list:

            expr_fields += get_expr_fields(field.type)

        if field.type.is_container:

            expr_fields += resolve_expr_fields(field.type)

    # try to resolve expr fields

    for e in expr_fields:

        if e not in all_fields and e not in unresolved:

            unresolved.append(e)

    return unresolved

def resolve_expr_fields_list(self, parents):

    """

    Find expr fields appearing in a list and descendents

    that cannot be resolved within the parents of the list.

    These are normally fields that need to be given as function parameters

    for length and iterator functions.

    """

    all_fields = []

    expr_fields = get_expr_fields(self)

    unresolved = []

    dont_resolve_this = ''

    for complex_obj in parents:

        for field in complex_obj.fields:

            if field.type.is_list and field.type.expr.op == 'calculate_len':

                dont_resolve_this = field.type.expr.lenfield_name

            if field.wire:

                all_fields.append(field)

    # try to resolve expr fields

    for e in expr_fields:

        if e not in all_fields and e not in unresolved and e.field_name != dont_resolve_this:

            unresolved.append(e)

    return unresolved

# resolve_expr_fields_list()

def get_serialize_params(context, self, buffer_var='_buffer', aux_var='_aux'):

    """

    functions like _serialize(), _unserialize(), and _unpack() sometimes need additional parameters:

    E.g. in order to unpack switch, extra parameters might be needed to evaluate the switch

    expression. This function tries to resolve all fields within a structure, and returns the

    unresolved fields as the list of external parameters.

    """

    def add_param(params, param):

        if param not in params:

            params.append(param)

    # collect all fields into param_fields

    param_fields = []

    wire_fields = []

    for field in self.fields:

        if field.visible:

            # the field should appear as a parameter in the function call

            param_fields.append(field)

        if field.wire and not field.auto:

            if field.type.fixed_size() and not self.is_switch:

                # field in the xcb_out structure

                wire_fields.append(field)

        # fields like 'pad0' are skipped!

    # in case of switch, parameters always contain any fields referenced in the switch expr

    # we do not need any variable size fields here, as the switch data type contains both

    # fixed and variable size fields

    if self.is_switch:

        param_fields = get_expr_fields(self)

    # _serialize()/_unserialize()/_unpack() function parameters

    # note: don't use set() for params, it is unsorted

    params = []

    parameter = ''

    if self.is_list:

       parameter = self.type.expr.lenfield_name

    # 1. the parameter for the void * buffer

    if  'serialize' == context:

        params.append(('void', '**', buffer_var))

    elif context in ('unserialize', 'unpack', 'sizeof'):

        params.append(('const void', '*', buffer_var))

    # 2. any expr fields that cannot be resolved within self and descendants

    unresolved_fields = resolve_expr_fields(self)

    for f in unresolved_fields:

        add_param(params, (f.c_field_type, '', f.c_field_name))

    # 3. param_fields contain the fields necessary to evaluate the switch expr or any other fields

    #    that do not appear in the data type struct

    for p in param_fields:

        if self.is_switch:

            typespec = p.c_field_const_type

            pointerspec = p.c_pointer

            add_param(params, (typespec, pointerspec, p.c_field_name))

        else:

            if p.visible and not p.wire and not p.auto and p.field_name != parameter:

                typespec = p.c_field_type

                pointerspec = ''

                add_param(params, (typespec, pointerspec, p.c_field_name))

    # 4. aux argument

    if 'serialize' == context:

        add_param(params, ('const %s' % self.c_type, '*', aux_var))

    elif 'unserialize' == context:

        add_param(params, ('%s' % self.c_type, '**', aux_var))

    elif 'unpack' == context:

        add_param(params, ('%s' % self.c_type, '*', aux_var))

    # 5. switch contains all variable size fields as struct members

    #    for other data types though, these have to be supplied separately

    #    this is important for the special case of intermixed fixed and

    #    variable size fields

    if not self.is_switch and 'serialize' == context:

        for p in param_fields:

            if not p.type.fixed_size():

                add_param(params, (p.c_field_const_type, '*', p.c_field_name))

    return (param_fields, wire_fields, params)

def _c_serialize_helper_insert_padding(context, complex_type, code_lines, space, postpone, is_case_or_bitcase):

    code_lines.append('%s    /* insert padding */' % space)

    if is_case_or_bitcase:

        code_lines.append(

            '%s    xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1);'

            % space)

    else:

        code_lines.append(

            '%s    xcb_pad = -xcb_block_len & (xcb_align_to - 1);' % space)

    code_lines.append('%s    xcb_buffer_len += xcb_block_len + xcb_pad;' % space)

    if not postpone:

        code_lines.append('%s    if (0 != xcb_pad) {' % space)

        if 'serialize' == context:

            code_lines.append('%s        xcb_parts[xcb_parts_idx].iov_base = xcb_pad0;' % space)

            code_lines.append('%s        xcb_parts[xcb_parts_idx].iov_len = xcb_pad;' % space)

            code_lines.append('%s        xcb_parts_idx++;' % space)

        elif context in ('unserialize', 'unpack', 'sizeof'):

            code_lines.append('%s        xcb_tmp += xcb_pad;' % space)

        code_lines.append('%s        xcb_pad = 0;' % space)

        code_lines.append('%s    }' % space)

    code_lines.append('%s    xcb_block_len = 0;' % space)

    if is_case_or_bitcase:

        code_lines.append('%s    xcb_padding_offset = 0;' % space)

    # keep tracking of xcb_parts entries for serialize

    return 1

def _c_serialize_helper_switch(context, self, complex_name,

                               code_lines, temp_vars,

                               space, prefix):

    count = 0

    switch_expr = _c_accessor_get_expr(self.expr, None)

    for b in self.bitcases:

        len_expr = len(b.type.expr)

        compare_operator = '&'

        if b.type.is_case:

            compare_operator = '=='

        else:

            compare_operator = '&'

        for n, expr in enumerate(b.type.expr):

            bitcase_expr = _c_accessor_get_expr(expr, None)

            # only one <enumref> in the <bitcase>

            if len_expr == 1: