[libxcb,3/7] c_client.py: remove trailing whitespace

Submitted by Ran Benita on Feb. 23, 2014, 8:55 p.m.

Details

Message ID 1393188921-19614-4-git-send-email-ran234@gmail.com
State Accepted
Headers show

Not browsing as part of any series.

Commit Message

Ran Benita Feb. 23, 2014, 8:55 p.m.
These are extra annoying in python code.

Signed-off-by: Ran Benita <ran234@gmail.com>
---
 src/c_client.py | 342 ++++++++++++++++++++++++++++----------------------------
 1 file changed, 171 insertions(+), 171 deletions(-)

Patch hide | download patch | download mbox

diff --git a/src/c_client.py b/src/c_client.py
index c0119e5..301f8dc 100644
--- a/src/c_client.py
+++ b/src/c_client.py
@@ -28,7 +28,7 @@  _clines = []
 _clevel = 0
 _ns = None
 
-# global variable to keep track of serializers and 
+# global variable to keep track of serializers and
 # switch data types due to weird dependencies
 finished_serializers = []
 finished_sizeof = []
@@ -44,13 +44,13 @@  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.
@@ -68,7 +68,7 @@  def _h_setlevel(idx):
     while len(_hlines) <= idx:
         _hlines.append([])
     _hlevel = idx
-    
+
 def _c_setlevel(idx):
     '''
     Changes the array that source lines are written to.
@@ -78,7 +78,7 @@  def _c_setlevel(idx):
     while len(_clines) <= idx:
         _clines.append([])
     _clevel = idx
-    
+
 def _n_item(str):
     '''
     Does C-name conversion on a single string fragment.
@@ -90,7 +90,7 @@  def _n_item(str):
         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.
@@ -111,7 +111,7 @@  def _ext(str):
         return _n_item(str).lower()
     else:
         return str.lower()
-    
+
 def _n(list):
     '''
     Does C-name conversion on a tuple of strings.
@@ -142,7 +142,7 @@  def _t(list):
     else:
         parts = [list[0]] + [_n_item(i) for i in list[1:]] + ['t']
     return '_'.join(parts).lower()
-        
+
 
 def c_open(self):
     '''
@@ -185,7 +185,7 @@  def c_open(self):
     _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)')
 
@@ -339,7 +339,7 @@  def _c_type_setup(self, name, postfix):
             _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): 
+                if (field.type.nmemb is None):
                     self.need_sizeof = True
 
             field.c_field_type = _t(field.field_type)
@@ -384,17 +384,17 @@  def _c_type_setup(self, name, postfix):
             else:
                 self.last_varsized_field = field
                 prev_varsized_field = field
-                prev_varsized_offset = 0                    
+                prev_varsized_offset = 0
 
             if self.var_followed_by_fixed_fields:
                 if field.type.fixed_size():
                     field.prev_varsized_field = None
-                            
+
     if self.need_serialize:
-        # when _unserialize() is wanted, create _sizeof() as well for consistency reasons 
+        # when _unserialize() is wanted, create _sizeof() as well for consistency reasons
         self.need_sizeof = True
 
-    # as switch does never appear at toplevel, 
+    # as switch does never appear at toplevel,
     # continue here with type construction
     if self.is_switch:
         if self.c_type not in finished_switch:
@@ -404,7 +404,7 @@  def _c_type_setup(self, name, postfix):
             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 
+                # no list with switch as element, so no call to
                 # _c_iterator(field.type, field_name) necessary
 
     if not self.is_bitcase:
@@ -418,7 +418,7 @@  def _c_type_setup(self, name, postfix):
                 #   special cases -> unserialize
                 if self.is_switch or self.var_followed_by_fixed_fields:
                     _c_serialize('unserialize', self)
-                    
+
         if self.need_sizeof:
             if self.c_sizeof_name not in finished_sizeof:
                 if not module.namespace.is_ext or self.name[:2] == module.namespace.prefix:
@@ -445,7 +445,7 @@  def _c_helper_absolute_name(prefix, field=None):
         prefix_str += _cpp(field.field_name)
     return prefix_str
 # _c_absolute_name
-    
+
 def _c_helper_field_mapping(complex_type, prefix, flat=False):
     """
     generate absolute names, based on prefix, for all fields starting from complex_type
@@ -458,7 +458,7 @@  def _c_helper_field_mapping(complex_type, prefix, flat=False):
                 switch_name, switch_sep, switch_type = prefix[-1]
                 bitcase_prefix = prefix + [(b.type.name[-1], '.', b.type)]
             else:
-                bitcase_prefix = prefix 
+                bitcase_prefix = prefix
 
             if (True==flat and not b.type.has_name) or False==flat:
                 all_fields.update(_c_helper_field_mapping(b.type, bitcase_prefix, flat))
@@ -505,7 +505,7 @@  def _c_helper_resolve_field_names (prefix):
 
 def get_expr_fields(self):
     """
-    get the Fields referenced by switch or list expression 
+    get the Fields referenced by switch or list expression
     """
     def get_expr_field_names(expr):
         if expr.op is None:
@@ -520,7 +520,7 @@  def get_expr_fields(self):
             elif expr.op == 'popcount':
                 return get_expr_field_names(expr.rhs)
             elif expr.op == 'sumof':
-                # sumof expr references another list, 
+                # sumof expr references another list,
                 # we need that list's length field here
                 field = None
                 for f in expr.lenfield_parent.fields:
@@ -536,7 +536,7 @@  def get_expr_fields(self):
             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)
 
@@ -549,7 +549,7 @@  def get_expr_fields(self):
     resolved_fields_names = list(filter(lambda x: x in all_fields.keys(), unresolved_fields_names))
     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
 # get_expr_fields()
@@ -576,13 +576,13 @@  def resolve_expr_fields(complex_obj):
             unresolved.append(e)
     return unresolved
 # resolve_expr_fields()
-            
+
 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. 
+    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:
@@ -601,9 +601,9 @@  def get_serialize_params(context, self, buffer_var='_buffer', aux_var='_aux'):
                 # 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 
+    # 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)
@@ -611,7 +611,7 @@  def get_serialize_params(context, self, buffer_var='_buffer', aux_var='_aux'):
     # _serialize()/_unserialize()/_unpack() function parameters
     # note: don't use set() for params, it is unsorted
     params = []
-    
+
     # 1. the parameter for the void * buffer
     if  'serialize' == context:
         params.append(('void', '**', buffer_var))
@@ -628,25 +628,25 @@  def get_serialize_params(context, self, buffer_var='_buffer', aux_var='_aux'):
     for p in param_fields:
         if self.is_switch:
             typespec = p.c_field_const_type
-            pointerspec = p.c_pointer 
+            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:
                 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: 
+    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 
+    #    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:
@@ -674,20 +674,20 @@  def _c_serialize_helper_insert_padding(context, code_lines, space, postpone):
 
         code_lines.append('%s        xcb_pad = 0;' % space)
         code_lines.append('%s    }' % space)
-        
+
     code_lines.append('%s    xcb_block_len = 0;' % space)
 
     # keep tracking of xcb_parts entries for serialize
     return 1
 # _c_serialize_helper_insert_padding()
 
-def _c_serialize_helper_switch(context, self, complex_name, 
-                               code_lines, temp_vars, 
+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:            
+    for b in self.bitcases:
         len_expr = len(b.type.expr)
         for n, expr in enumerate(b.type.expr):
             bitcase_expr = _c_accessor_get_expr(expr, None)
@@ -705,11 +705,11 @@  def _c_serialize_helper_switch(context, self, complex_name,
         b_prefix = prefix
         if b.type.has_name:
             b_prefix = prefix + [(b.c_field_name, '.', b.type)]
-            
-        count += _c_serialize_helper_fields(context, b.type, 
-                                            code_lines, temp_vars, 
-                                            "%s    " % space, 
-                                            b_prefix, 
+
+        count += _c_serialize_helper_fields(context, b.type,
+                                            code_lines, temp_vars,
+                                            "%s    " % space,
+                                            b_prefix,
                                             is_bitcase = True)
         code_lines.append('    }')
 
@@ -719,7 +719,7 @@  def _c_serialize_helper_switch(context, self, complex_name,
 #        # padding
 #        code_lines.append('%s    xcb_pad = -xcb_block_len & 3;' % space)
 #        code_lines.append('%s    xcb_buffer_len += xcb_block_len + xcb_pad;' % space)
-   
+
     return count
 # _c_serialize_helper_switch
 
@@ -735,7 +735,7 @@  def _c_serialize_helper_switch_field(context, self, field, c_switch_variable, pr
     # find the parameters that need to be passed to _serialize()/_unpack():
     # all switch expr fields must be given as parameters
     args = get_expr_fields(field.type)
-    # length fields for variable size types in switch, normally only some of need 
+    # length fields for variable size types in switch, normally only some of need
     # need to be passed as parameters
     switch_len_fields = resolve_expr_fields(field.type)
 
@@ -745,7 +745,7 @@  def _c_serialize_helper_switch_field(context, self, field, c_switch_variable, pr
     if len(bitcase_unresolved) != 0:
         raise Exception('unresolved fields within bitcase is not supported at this point')
 
-    # get the C names for the parameters  
+    # get the C names for the parameters
     c_field_names = ''
     for a in switch_len_fields:
         c_field_names += "%s, " % field_mapping[a.c_field_name][0]
@@ -755,16 +755,16 @@  def _c_serialize_helper_switch_field(context, self, field, c_switch_variable, pr
     # call _serialize()/_unpack() to determine the actual size
     if 'serialize' == context:
         length = "%s(&%s, %s&%s%s)" % (field.type.c_serialize_name, c_switch_variable,
-                                       c_field_names, prefix_str, field.c_field_name) 
+                                       c_field_names, prefix_str, field.c_field_name)
     elif context in ('unserialize', 'unpack'):
-        length = "%s(xcb_tmp, %s&%s%s)" % (field.type.c_unpack_name, 
+        length = "%s(xcb_tmp, %s&%s%s)" % (field.type.c_unpack_name,
                                            c_field_names, prefix_str, field.c_field_name)
 
     return length
 # _c_serialize_helper_switch_field()
 
-def _c_serialize_helper_list_field(context, self, field, 
-                                   code_lines, temp_vars, 
+def _c_serialize_helper_list_field(context, self, field,
+                                   code_lines, temp_vars,
                                    space, prefix):
     """
     helper function to cope with lists of variable length
@@ -773,21 +773,21 @@  def _c_serialize_helper_list_field(context, self, field,
     prefix_str = _c_helper_absolute_name(prefix)
     param_fields, wire_fields, params = get_serialize_params('sizeof', self)
     param_names = [p[2] for p in params]
-    
+
     expr_fields_names = [f.field_name for f in get_expr_fields(field.type)]
     resolved = list(filter(lambda x: x in param_names, expr_fields_names))
     unresolved = list(filter(lambda x: x not in param_names, expr_fields_names))
-    
+
     field_mapping = {}
     for r in resolved:
         field_mapping[r] = (r, None)
-    
+
     if len(unresolved)>0:
         tmp_prefix = prefix
         if len(tmp_prefix)==0:
-            raise Exception("found an empty prefix while resolving expr field names for list %s", 
-                            field.c_field_name)        
-        
+            raise Exception("found an empty prefix while resolving expr field names for list %s",
+                            field.c_field_name)
+
         field_mapping.update(_c_helper_resolve_field_names(prefix))
         resolved += list(filter(lambda x: x in field_mapping, unresolved))
         unresolved = list(filter(lambda x: x not in field_mapping, unresolved))
@@ -799,7 +799,7 @@  def _c_serialize_helper_list_field(context, self, field,
     # default: list with fixed size elements
     length = '%s * sizeof(%s)' % (list_length, field.type.member.c_wiretype)
 
-    # list with variable-sized elements 
+    # list with variable-sized elements
     if not field.type.member.fixed_size():
         length = ''
         if context in ('unserialize', 'sizeof', 'unpack'):
@@ -812,12 +812,12 @@  def _c_serialize_helper_list_field(context, self, field,
             # loop over all list elements and call sizeof repeatedly
             # this should be a bit faster than using the iterators
             code_lines.append("%s    for(i=0; i<%s; i++) {" % (space, list_length))
-            code_lines.append("%s        xcb_tmp_len = %s(xcb_tmp);" % 
+            code_lines.append("%s        xcb_tmp_len = %s(xcb_tmp);" %
                               (space, field.type.c_sizeof_name))
             code_lines.append("%s        xcb_block_len += xcb_tmp_len;" % space)
             code_lines.append("%s        xcb_tmp += xcb_tmp_len;" % space)
-            code_lines.append("%s    }" % space)                  
-      
+            code_lines.append("%s    }" % space)
+
         elif 'serialize' == context:
             code_lines.append('%s    xcb_parts[xcb_parts_idx].iov_len = 0;' % space)
             code_lines.append('%s    xcb_tmp = (char *) %s%s;' % (space, prefix_str, field.c_field_name))
@@ -826,12 +826,12 @@  def _c_serialize_helper_list_field(context, self, field,
             code_lines.append('%s        xcb_parts[xcb_parts_idx].iov_len += xcb_block_len;' % space)
             code_lines.append('%s    }' % space)
             code_lines.append('%s    xcb_block_len = xcb_parts[xcb_parts_idx].iov_len;' % space)
-            
+
     return length
 # _c_serialize_helper_list_field()
 
-def _c_serialize_helper_fields_fixed_size(context, self, field, 
-                                          code_lines, temp_vars, 
+def _c_serialize_helper_fields_fixed_size(context, self, field,
+                                          code_lines, temp_vars,
                                           space, prefix):
     # keep the C code a bit more readable by giving the field name
     if not self.is_bitcase:
@@ -847,14 +847,14 @@  def _c_serialize_helper_fields_fixed_size(context, self, field,
 
     if context in ('unserialize', 'unpack', 'sizeof'):
         # default: simple cast
-        value = '    %s = *(%s *)xcb_tmp;' % (abs_field_name, field.c_field_type) 
-        
+        value = '    %s = *(%s *)xcb_tmp;' % (abs_field_name, field.c_field_type)
+
         # padding - we could probably just ignore it
         if field.type.is_pad and field.type.nmemb > 1:
             value = ''
             for i in range(field.type.nmemb):
-                code_lines.append('%s    %s[%d] = *(%s *)xcb_tmp;' % 
-                                  (space, abs_field_name, i, field.c_field_type)) 
+                code_lines.append('%s    %s[%d] = *(%s *)xcb_tmp;' %
+                                  (space, abs_field_name, i, field.c_field_type))
             # total padding = sizeof(pad0) * nmemb
             length += " * %d" % field.type.nmemb
 
@@ -863,15 +863,15 @@  def _c_serialize_helper_fields_fixed_size(context, self, field,
             raise Exception('list with fixed number of elemens unhandled in _unserialize()')
 
     elif 'serialize' == context:
-        value = '    xcb_parts[xcb_parts_idx].iov_base = (char *) ' 
+        value = '    xcb_parts[xcb_parts_idx].iov_base = (char *) '
 
         if field.type.is_expr:
             # need to register a temporary variable for the expression in case we know its type
             if field.type.c_type is None:
-                raise Exception("type for field '%s' (expression '%s') unkown" % 
+                raise Exception("type for field '%s' (expression '%s') unkown" %
                                 (field.field_name, _c_accessor_get_expr(field.type.expr)))
-            
-            temp_vars.append('    %s xcb_expr_%s = %s;' % (field.type.c_type, _cpp(field.field_name), 
+
+            temp_vars.append('    %s xcb_expr_%s = %s;' % (field.type.c_type, _cpp(field.field_name),
                                                            _c_accessor_get_expr(field.type.expr, prefix)))
             value += "&xcb_expr_%s;" % _cpp(field.field_name)
 
@@ -896,15 +896,15 @@  def _c_serialize_helper_fields_fixed_size(context, self, field,
     return (value, length)
 # _c_serialize_helper_fields_fixed_size()
 
-def _c_serialize_helper_fields_variable_size(context, self, field, 
-                                             code_lines, temp_vars, 
+def _c_serialize_helper_fields_variable_size(context, self, field,
+                                             code_lines, temp_vars,
                                              space, prefix):
     prefix_str = _c_helper_absolute_name(prefix)
 
     if context in ('unserialize', 'unpack', 'sizeof'):
         value = ''
         var_field_name = 'xcb_tmp'
-        
+
         # special case: intermixed fixed and variable size fields
         if self.var_followed_by_fixed_fields and 'unserialize' == context:
             value = '    %s = (%s *)xcb_tmp;' % (field.c_field_name, field.c_field_type)
@@ -912,9 +912,9 @@  def _c_serialize_helper_fields_variable_size(context, self, field,
         # special case: switch
         if 'unpack' == context:
             value = '    %s%s = (%s *)xcb_tmp;' % (prefix_str, field.c_field_name, field.c_field_type)
-            
+
     elif 'serialize' == context:
-        # variable size fields appear as parameters to _serialize() if the 
+        # variable size fields appear as parameters to _serialize() if the
         # 'toplevel' container is not a switch
         prefix_string = prefix_str if prefix[0][2].is_switch else ''
         var_field_name = "%s%s" % (prefix_string, field.c_field_name)
@@ -929,19 +929,19 @@  def _c_serialize_helper_fields_variable_size(context, self, field,
             # in any context, list is already a pointer, so the default assignment is ok
             code_lines.append("%s%s" % (space, value))
             value = ''
-        length = _c_serialize_helper_list_field(context, self, field, 
-                                                code_lines, temp_vars, 
+        length = _c_serialize_helper_list_field(context, self, field,
+                                                code_lines, temp_vars,
                                                 space, prefix)
-        
+
     elif field.type.is_switch:
         value = ''
         if context == 'serialize':
             # the _serialize() function allocates the correct amount memory if given a NULL pointer
             value = '    xcb_parts[xcb_parts_idx].iov_base = (char *)0;'
-        length = _c_serialize_helper_switch_field(context, self, field, 
-                                                  'xcb_parts[xcb_parts_idx].iov_base', 
+        length = _c_serialize_helper_switch_field(context, self, field,
+                                                  'xcb_parts[xcb_parts_idx].iov_base',
                                                   prefix)
-        
+
     else:
         # in all remaining special cases - call _sizeof()
         length = "%s(%s)" % (field.type.c_sizeof_name, var_field_name)
@@ -949,8 +949,8 @@  def _c_serialize_helper_fields_variable_size(context, self, field,
     return (value, length)
 # _c_serialize_helper_fields_variable_size
 
-def _c_serialize_helper_fields(context, self, 
-                               code_lines, temp_vars, 
+def _c_serialize_helper_fields(context, self,
+                               code_lines, temp_vars,
                                space, prefix, is_bitcase):
     count = 0
     need_padding = False
@@ -961,20 +961,20 @@  def _c_serialize_helper_fields(context, self,
             if not ((field.wire and not field.auto) or 'unserialize' == context):
                 continue
 
-        # switch/bitcase: fixed size fields must be considered explicitly 
+        # switch/bitcase: fixed size fields must be considered explicitly
         if field.type.fixed_size():
             if self.is_bitcase or self.var_followed_by_fixed_fields:
                 if prev_field_was_variable and need_padding:
                     # insert padding
-#                    count += _c_serialize_helper_insert_padding(context, code_lines, space, 
+#                    count += _c_serialize_helper_insert_padding(context, code_lines, space,
 #                                                                self.var_followed_by_fixed_fields)
                     prev_field_was_variable = False
 
                 # prefix for fixed size fields
                 fixed_prefix = prefix
 
-                value, length = _c_serialize_helper_fields_fixed_size(context, self, field, 
-                                                                      code_lines, temp_vars, 
+                value, length = _c_serialize_helper_fields_fixed_size(context, self, field,
+                                                                      code_lines, temp_vars,
                                                                       space, fixed_prefix)
             else:
                 continue
@@ -984,7 +984,7 @@  def _c_serialize_helper_fields(context, self,
             if field.type.is_pad:
                 # Variable length pad is <pad align= />
                 code_lines.append('%s    xcb_align_to = %d;' % (space, field.type.align))
-                count += _c_serialize_helper_insert_padding(context, code_lines, space, 
+                count += _c_serialize_helper_insert_padding(context, code_lines, space,
                                                         self.var_followed_by_fixed_fields)
                 continue
             else:
@@ -997,23 +997,23 @@  def _c_serialize_helper_fields(context, self,
                                                                          code_lines, temp_vars,
                                                                          space, prefix)
                 prev_field_was_variable = True
-        
+
         # save (un)serialization C code
         if '' != value:
-            code_lines.append('%s%s' % (space, value))    
-        
+            code_lines.append('%s%s' % (space, value))
+
         if field.type.fixed_size():
             if is_bitcase or self.var_followed_by_fixed_fields:
                 # keep track of (un)serialized object's size
                 code_lines.append('%s    xcb_block_len += %s;' % (space, length))
                 if context in ('unserialize', 'unpack', 'sizeof'):
                     code_lines.append('%s    xcb_tmp += %s;' % (space, length))
-        else: 
+        else:
             # variable size objects or bitcase:
             #   value & length might have been inserted earlier for special cases
             if '' != length:
                 # special case: intermixed fixed and variable size fields
-                if (not field.type.fixed_size() and 
+                if (not field.type.fixed_size() and
                     self.var_followed_by_fixed_fields and 'unserialize' == context):
                     temp_vars.append('    int %s_len;' % field.c_field_name)
                     code_lines.append('%s    %s_len = %s;' % (space, field.c_field_name, length))
@@ -1024,7 +1024,7 @@  def _c_serialize_helper_fields(context, self,
                     # increase pointer into the byte stream accordingly
                     if context in ('unserialize', 'sizeof', 'unpack'):
                         code_lines.append('%s    xcb_tmp += xcb_block_len;' % space)
-                        
+
         if 'serialize' == context:
             if '' != length:
                 code_lines.append('%s    xcb_parts[xcb_parts_idx].iov_len = %s;' % (space, length))
@@ -1036,12 +1036,12 @@  def _c_serialize_helper_fields(context, self,
         need_padding = True
         if self.var_followed_by_fixed_fields:
             need_padding = False
-        
+
     return count
-# _c_serialize_helper_fields()    
+# _c_serialize_helper_fields()
 
-def _c_serialize_helper(context, complex_type, 
-                        code_lines, temp_vars, 
+def _c_serialize_helper(context, complex_type,
+                        code_lines, temp_vars,
                         space='', prefix=[]):
     # count tracks the number of fields to serialize
     count = 0
@@ -1055,15 +1055,15 @@  def _c_serialize_helper(context, complex_type,
             complex_name = 'xcb_out'
         else:
             complex_name = '_aux'
-    
+
     # special case: switch is serialized by evaluating each bitcase separately
     if self.is_switch:
-        count += _c_serialize_helper_switch(context, self, complex_name, 
-                                            code_lines, temp_vars, 
+        count += _c_serialize_helper_switch(context, self, complex_name,
+                                            code_lines, temp_vars,
                                             space, prefix)
 
     # all other data types can be evaluated one field a time
-    else: 
+    else:
         # unserialize & fixed size fields: simply cast the buffer to the respective xcb_out type
         if context in ('unserialize', 'unpack', 'sizeof') and not self.var_followed_by_fixed_fields:
             code_lines.append('%s    xcb_block_len += sizeof(%s);' % (space, self.c_type))
@@ -1071,18 +1071,18 @@  def _c_serialize_helper(context, complex_type,
             code_lines.append('%s    xcb_buffer_len += xcb_block_len;' % space)
             code_lines.append('%s    xcb_block_len = 0;' % space)
 
-        count += _c_serialize_helper_fields(context, self, 
-                                            code_lines, temp_vars, 
+        count += _c_serialize_helper_fields(context, self,
+                                            code_lines, temp_vars,
                                             space, prefix, False)
     # "final padding"
     count += _c_serialize_helper_insert_padding(context, code_lines, space, False)
 
-    return count    
+    return count
 # _c_serialize_helper()
 
 def _c_serialize(context, self):
     """
-    depending on the context variable, generate _serialize(), _unserialize(), _unpack(), or _sizeof() 
+    depending on the context variable, generate _serialize(), _unserialize(), _unpack(), or _sizeof()
     for the ComplexType variable self
     """
     _h_setlevel(1)
@@ -1095,25 +1095,25 @@  def _c_serialize(context, self):
     if self.is_switch and 'unserialize' == context:
         context = 'unpack'
 
-    cases = { 'serialize'   : self.c_serialize_name, 
-              'unserialize' : self.c_unserialize_name, 
-              'unpack'      : self.c_unpack_name, 
+    cases = { 'serialize'   : self.c_serialize_name,
+              'unserialize' : self.c_unserialize_name,
+              'unpack'      : self.c_unpack_name,
               'sizeof'      : self.c_sizeof_name }
     func_name = cases[context]
-            
+
     param_fields, wire_fields, params = get_serialize_params(context, self)
     variable_size_fields = 0
     # maximum space required for type definition of function arguments
     maxtypelen = 0
 
-    # determine N(variable_fields) 
+    # determine N(variable_fields)
     for field in param_fields:
         # if self.is_switch, treat all fields as if they are variable sized
         if not field.type.fixed_size() or self.is_switch:
             variable_size_fields += 1
     # determine maxtypelen
     for p in params:
-        maxtypelen = max(maxtypelen, len(p[0]) + len(p[1]))    
+        maxtypelen = max(maxtypelen, len(p[0]) + len(p[1]))
 
     # write to .c/.h
     indent = ' '*(len(func_name)+2)
@@ -1191,7 +1191,7 @@  def _c_serialize(context, self):
     variable_size_fields = count
     if 'serialize' == context:
         temp_vars.append('    unsigned int xcb_pad = 0;')
-        temp_vars.append('    char xcb_pad0[3] = {0, 0, 0};') 
+        temp_vars.append('    char xcb_pad0[3] = {0, 0, 0};')
         temp_vars.append('    struct iovec xcb_parts[%d];' % count)
         temp_vars.append('    unsigned int xcb_parts_idx = 0;')
         temp_vars.append('    unsigned int xcb_block_len = 0;')
@@ -1211,7 +1211,7 @@  def _c_serialize(context, self):
 
             _c('    unsigned int xcb_buffer_len = 0;')
             _c('    unsigned int xcb_block_len = 0;')
-            _c('    unsigned int xcb_pad = 0;')        
+            _c('    unsigned int xcb_pad = 0;')
             _c('    unsigned int xcb_align_to = 0;')
 
     _c('')
@@ -1222,7 +1222,7 @@  def _c_serialize(context, self):
         _c(l)
 
     # variable sized fields have been collected, now
-    # allocate memory and copy everything into a continuous memory area 
+    # allocate memory and copy everything into a continuous memory area
     # note: this is not necessary in case of unpack
     if context in ('serialize', 'unserialize'):
         # unserialize: check for sizeof-only invocation
@@ -1261,7 +1261,7 @@  def _c_serialize(context, self):
                 _c('        if (0 != xcb_parts[i].iov_len)')
                 _c('            xcb_tmp += xcb_parts[i].iov_len;')
                 _c('    }')
-            
+
         # unserialize: assign variable size fields individually
         if 'unserialize' == context:
             _c('    xcb_tmp = ((char *)*_aux)+xcb_buffer_len;')
@@ -1271,7 +1271,7 @@  def _c_serialize(context, self):
                     _c('    xcb_tmp -= %s_len;', field.c_field_name)
                     _c('    memmove(xcb_tmp, %s, %s_len);', field.c_field_name, field.c_field_name)
             _c('    *%s = xcb_out;', aux_ptr)
- 
+
     _c('')
     _c('    return xcb_buffer_len;')
     _c('}')
@@ -1340,11 +1340,11 @@  def _c_iterator(self, name):
 
         if self.is_union:
             # FIXME - how to determine the size of a variable size union??
-            _c('    /* FIXME - determine the size of the union %s */', self.c_type)            
+            _c('    /* FIXME - determine the size of the union %s */', self.c_type)
         else:
             if self.need_sizeof:
                 _c('    xcb_generic_iterator_t child;')
-                _c('    child.data = (%s *)(((char *)R) + %s(R));', 
+                _c('    child.data = (%s *)(((char *)R) + %s(R));',
                    self.c_type, self.c_sizeof_name)
                 _c('    i->index = (char *) child.data - (char *) i->data;')
             else:
@@ -1404,7 +1404,7 @@  def _c_iterator(self, name):
 def _c_accessor_get_length(expr, field_mapping=None):
     '''
     Figures out what C code is needed to get a length field.
-    The field_mapping parameter can be used to change the absolute name of a length field. 
+    The field_mapping parameter can be used to change the absolute name of a length field.
     For fields that follow a variable-length field, use the accessor.
     Otherwise, just reference the structure field directly.
     '''
@@ -1413,7 +1413,7 @@  def _c_accessor_get_length(expr, field_mapping=None):
     if lenfield_name is not None:
         if field_mapping is not None:
             lenfield_name = field_mapping[lenfield_name][0]
- 
+
     if expr.lenfield is not None and expr.lenfield.prev_varsized_field is not None:
         # special case: variable and fixed size fields are intermixed
         # if the lenfield is among the fixed size fields, there is no need
@@ -1427,7 +1427,7 @@  def _c_accessor_get_length(expr, field_mapping=None):
 def _c_accessor_get_expr(expr, field_mapping):
     '''
     Figures out what C code is needed to get the length of a list field.
-    The field_mapping parameter can be used to change the absolute name of a length field. 
+    The field_mapping parameter can be used to change the absolute name of a length field.
     Recurses for math operations.
     Returns bitcount for value-mask fields.
     Otherwise, uses the value of the length field.
@@ -1460,8 +1460,8 @@  def _c_accessor_get_expr(expr, field_mapping):
         c_length_func = _c_accessor_get_expr(field.type.expr, field_mapping)
         return 'xcb_sumof(%s, %s)' % (list_name, c_length_func)
     elif expr.op != None:
-        return ('(' + _c_accessor_get_expr(expr.lhs, field_mapping) + 
-                ' ' + expr.op + ' ' + 
+        return ('(' + _c_accessor_get_expr(expr.lhs, field_mapping) +
+                ' ' + expr.op + ' ' +
                 _c_accessor_get_expr(expr.rhs, field_mapping) + ')')
     elif expr.bitfield:
         return 'xcb_popcount(' + lenexp + ')'
@@ -1506,7 +1506,7 @@  def _c_accessors_field(self, field):
             _c('    return (%s *) (R + 1);', field.c_field_type)
         else:
             _c('    xcb_generic_iterator_t prev = %s;', _c_iterator_get_end(field.prev_varsized_field, 'R'))
-            _c('    return * (%s *) ((char *) prev.data + XCB_TYPE_PAD(%s, prev.index) + %d);', 
+            _c('    return * (%s *) ((char *) prev.data + XCB_TYPE_PAD(%s, prev.index) + %d);',
                field.c_field_type, type_pad_type(field.first_field_after_varsized.type.c_type), field.prev_varsized_offset)
         _c('}')
     else:
@@ -1533,15 +1533,15 @@  def _c_accessors_field(self, field):
         if field.prev_varsized_field is None:
             _c('    return (%s) (R + 1);', return_type)
             # note: the special case 'variable fields followed by fixed size fields'
-            #       is not of any consequence here, since the ordering gets 
+            #       is not of any consequence here, since the ordering gets
             #       'corrected' in the reply function
         else:
             _c('    xcb_generic_iterator_t prev = %s;', _c_iterator_get_end(field.prev_varsized_field, 'R'))
-            _c('    return (%s) ((char *) prev.data + XCB_TYPE_PAD(%s, prev.index) + %d);', 
+            _c('    return (%s) ((char *) prev.data + XCB_TYPE_PAD(%s, prev.index) + %d);',
                return_type, type_pad_type(field.first_field_after_varsized.type.c_type), field.prev_varsized_offset)
         _c('}')
 
-    
+
 def _c_accessors_list(self, field):
     '''
     Declares the accessor functions for a list field.
@@ -1555,7 +1555,7 @@  def _c_accessors_list(self, field):
     # in case of switch, 2 params have to be supplied to certain accessor functions:
     #   1. the anchestor object (request or reply)
     #   2. the (anchestor) switch object
-    # the reason is that switch is either a child of a request/reply or nested in another switch, 
+    # the reason is that switch is either a child of a request/reply or nested in another switch,
     # so whenever we need to access a length field, we might need to refer to some anchestor type
     switch_obj = self if self.is_switch else None
     if self.is_bitcase:
@@ -1566,14 +1566,14 @@  def _c_accessors_list(self, field):
     params = []
     fields = {}
     parents = self.parents if hasattr(self, 'parents') else [self]
-    # 'R': parents[0] is always the 'toplevel' container type 
+    # 'R': parents[0] is always the 'toplevel' container type
     params.append(('const %s *R' % parents[0].c_type, parents[0]))
     fields.update(_c_helper_field_mapping(parents[0], [('R', '->', parents[0])], flat=True))
     # auxiliary object for 'R' parameters
     R_obj = parents[0]
 
     if switch_obj is not None:
-        # now look where the fields are defined that are needed to evaluate 
+        # now look where the fields are defined that are needed to evaluate
         # the switch expr, and store the parent objects in accessor_params and
         # the fields in switch_fields
 
@@ -1588,7 +1588,7 @@  def _c_accessors_list(self, field):
 
         # look for fields in the remaining containers
         for p in parents[2:] + [self]:
-            # the separator between parent and child is always '.' here, 
+            # the separator between parent and child is always '.' here,
             # because of nested switch statements
             if not p.is_bitcase or (p.is_bitcase and p.has_name):
                 prefix.append((p.name[-1], '.', p))
@@ -1624,7 +1624,7 @@  def _c_accessors_list(self, field):
             _c('    return (%s *) (R + 1);', field.c_field_type)
         else:
             _c('    xcb_generic_iterator_t prev = %s;', _c_iterator_get_end(field.prev_varsized_field, 'R'))
-            _c('    return (%s *) ((char *) prev.data + XCB_TYPE_PAD(%s, prev.index) + %d);', 
+            _c('    return (%s *) ((char *) prev.data + XCB_TYPE_PAD(%s, prev.index) + %d);',
                field.c_field_type, type_pad_type(field.first_field_after_varsized.type.c_type), field.prev_varsized_offset)
         _c('}')
 
@@ -1677,18 +1677,18 @@  def _c_accessors_list(self, field):
             _c('%s (const %s *R  /**< */)', field.c_end_name, c_type)
         _c('{')
         _c('    xcb_generic_iterator_t i;')
-        
+
         param = 'R' if switch_obj is None else 'S'
         if switch_obj is not None:
-            _c('    i.data = %s + %s;', fields[field.c_field_name][0], 
+            _c('    i.data = %s + %s;', fields[field.c_field_name][0],
                _c_accessor_get_expr(field.type.expr, fields))
         elif field.prev_varsized_field == None:
-            _c('    i.data = ((%s *) (R + 1)) + (%s);', field.type.c_wiretype, 
+            _c('    i.data = ((%s *) (R + 1)) + (%s);', field.type.c_wiretype,
                _c_accessor_get_expr(field.type.expr, fields))
         else:
-            _c('    xcb_generic_iterator_t child = %s;', 
+            _c('    xcb_generic_iterator_t child = %s;',
                _c_iterator_get_end(field.prev_varsized_field, 'R'))
-            _c('    i.data = ((%s *) child.data) + (%s);', field.type.c_wiretype, 
+            _c('    i.data = ((%s *) child.data) + (%s);', field.type.c_wiretype,
                _c_accessor_get_expr(field.type.expr, fields))
 
         _c('    i.rem = 0;')
@@ -1728,7 +1728,7 @@  def _c_accessors_list(self, field):
             _c('    i.data = (%s *) (R + 1);', field.c_field_type)
         else:
             _c('    xcb_generic_iterator_t prev = %s;', _c_iterator_get_end(field.prev_varsized_field, 'R'))
-            _c('    i.data = (%s *) ((char *) prev.data + XCB_TYPE_PAD(%s, prev.index));', 
+            _c('    i.data = (%s *) ((char *) prev.data + XCB_TYPE_PAD(%s, prev.index));',
                field.c_field_type, type_pad_type(field.c_field_type))
         if switch_obj is None:
             _c('    i.rem = %s;', _c_accessor_get_expr(field.type.expr, fields))
@@ -1740,7 +1740,7 @@  def _c_accessors(self, name, base):
     '''
     Declares the accessor functions for the fields of a structure.
     '''
-    # no accessors for switch itself - 
+    # no accessors for switch itself -
     # switch always needs to be unpacked explicitly
 #    if self.is_switch:
 #        pass
@@ -1792,7 +1792,7 @@  def _c_complex(self, force_packed = False):
             continue
         if field.wire:
             struct_fields.append(field)
-    
+
     for field in struct_fields:
         length = len(field.c_field_type)
         # account for '*' pointer_spec
@@ -1905,9 +1905,9 @@  def _c_request_helper(self, name, cookie_type, void, regular, aux=False, reply_f
             wire_fields.append(field)
         if field.type.need_serialize or field.type.need_sizeof:
             serial_fields.append(field)
-        
+
     for field in param_fields:
-        c_field_const_type = field.c_field_const_type 
+        c_field_const_type = field.c_field_const_type
         if field.type.need_serialize and not aux:
             c_field_const_type = "const void"
         if len(c_field_const_type) > maxtypelen:
@@ -1992,7 +1992,7 @@  def _c_request_helper(self, name, cookie_type, void, regular, aux=False, reply_f
     _hc(' ** @param xcb_connection_t%s *c', spacing)
 
     for field in param_fields:
-        c_field_const_type = field.c_field_const_type 
+        c_field_const_type = field.c_field_const_type
         if field.type.need_serialize and not aux:
             c_field_const_type = "const void"
         spacing = ' ' * (maxtypelen - len(c_field_const_type))
@@ -2014,17 +2014,17 @@  def _c_request_helper(self, name, cookie_type, void, regular, aux=False, reply_f
     count = len(param_fields)
     for field in param_fields:
         count = count - 1
-        c_field_const_type = field.c_field_const_type 
+        c_field_const_type = field.c_field_const_type
         c_pointer = field.c_pointer
         if field.type.need_serialize and not aux:
             c_field_const_type = "const void"
             c_pointer = '*'
         spacing = ' ' * (maxtypelen - len(c_field_const_type))
         comma = ',' if count else ');'
-        _h('%s%s%s %s%s  /**< */%s', func_spacing, c_field_const_type, 
+        _h('%s%s%s %s%s  /**< */%s', func_spacing, c_field_const_type,
            spacing, c_pointer, field.c_field_name, comma)
         comma = ',' if count else ')'
-        _c('%s%s%s %s%s  /**< */%s', func_spacing, c_field_const_type, 
+        _c('%s%s%s %s%s  /**< */%s', func_spacing, c_field_const_type,
            spacing, c_pointer, field.c_field_name, comma)
 
     count = 2
@@ -2052,7 +2052,7 @@  def _c_request_helper(self, name, cookie_type, void, regular, aux=False, reply_f
     if self.var_followed_by_fixed_fields:
         _c('    /* in the protocol description, variable size fields are followed by fixed size fields */')
         _c('    void *xcb_aux = 0;')
-        
+
 
     for idx, f in enumerate(serial_fields):
         if aux:
@@ -2063,8 +2063,8 @@  def _c_request_helper(self, name, cookie_type, void, regular, aux=False, reply_f
         _c('    char *xcb_tmp;')
     _c('    ')
     # simple request call tracing
-#    _c('    printf("in function %s\\n");' % func_name)     
- 
+#    _c('    printf("in function %s\\n");' % func_name)
+
     # fixed size fields
     for field in wire_fields:
         if field.type.fixed_size():
@@ -2082,8 +2082,8 @@  def _c_request_helper(self, name, cookie_type, void, regular, aux=False, reply_f
                     _c('    memcpy(xcb_out.%s, %s, %d);', field.c_field_name, field.c_field_name, field.type.nmemb)
 
     def get_serialize_args(type_obj, c_field_name, aux_var, context='serialize'):
-        serialize_args = get_serialize_params(context, type_obj, 
-                                              c_field_name, 
+        serialize_args = get_serialize_params(context, type_obj,
+                                              c_field_name,
                                               aux_var)[2]
         return reduce(lambda x,y: "%s, %s" % (x,y), [a[2] for a in serialize_args])
 
@@ -2107,21 +2107,21 @@  def _c_request_helper(self, name, cookie_type, void, regular, aux=False, reply_f
                     _c('    xcb_parts[%d].iov_base = (char *) %s;', count, field.c_field_name)
                     if field.type.is_list:
                         if field.type.member.fixed_size():
-                            _c('    xcb_parts[%d].iov_len = %s * sizeof(%s);', count, 
-                               _c_accessor_get_expr(field.type.expr, None), 
+                            _c('    xcb_parts[%d].iov_len = %s * sizeof(%s);', count,
+                               _c_accessor_get_expr(field.type.expr, None),
                                field.type.member.c_wiretype)
                         else:
                             list_length = _c_accessor_get_expr(field.type.expr, None)
-    
+
                             length = ''
                             _c("    xcb_parts[%d].iov_len = 0;" % count)
                             _c("    xcb_tmp = (char *)%s;", field.c_field_name)
                             _c("    for(i=0; i<%s; i++) {" % list_length)
-                            _c("        xcb_tmp_len = %s(xcb_tmp);" % 
+                            _c("        xcb_tmp_len = %s(xcb_tmp);" %
                                               (field.type.c_sizeof_name))
                             _c("        xcb_parts[%d].iov_len += xcb_tmp_len;" % count)
                             _c("        xcb_tmp += xcb_tmp_len;")
-                            _c("    }")                        
+                            _c("    }")
                     else:
                         # not supposed to happen
                         raise Exception("unhandled variable size field %s" % field.c_field_name)
@@ -2153,7 +2153,7 @@  def _c_request_helper(self, name, cookie_type, void, regular, aux=False, reply_f
     else:
         _c('    xcb_parts[2].iov_base = (char *) &xcb_out;')
         # request header: opcodes + length
-        _c('    xcb_parts[2].iov_len = 2*sizeof(uint8_t) + sizeof(uint16_t);') 
+        _c('    xcb_parts[2].iov_len = 2*sizeof(uint8_t) + sizeof(uint16_t);')
         count += 1
         # call _serialize()
         buffer_var = '&xcb_aux'
@@ -2167,9 +2167,9 @@  def _c_request_helper(self, name, cookie_type, void, regular, aux=False, reply_f
     for field in param_fields:
         if field.isfd:
             _c('    xcb_send_fd(c, %s);', field.c_field_name)
-    
+
     _c('    xcb_ret.sequence = xcb_send_request(c, %s, xcb_parts + 2, &xcb_req);', func_flags)
-    
+
     # free dyn. all. data, if any
     for f in free_calls:
         _c(f)
@@ -2183,7 +2183,7 @@  def _c_reply(self, name):
     spacing1 = ' ' * (len(self.c_cookie_type) - len('xcb_connection_t'))
     spacing2 = ' ' * (len(self.c_cookie_type) - len('xcb_generic_error_t'))
     spacing3 = ' ' * (len(self.c_reply_name) + 2)
-    
+
     # check if _unserialize() has to be called for any field
     def look_for_special_cases(complex_obj):
         unserialize_fields = []
@@ -2203,9 +2203,9 @@  def _c_reply(self, name):
                     if field.type.member.is_container:
                         unserialize_fields += look_for_special_cases(field.type.member)
         return unserialize_fields
-    
+
     unserialize_fields = look_for_special_cases(self.reply)
-    
+
     _h('')
     _h('/**')
     _h(' * Return the reply')
@@ -2240,10 +2240,10 @@  def _c_reply(self, name):
     _h('%sxcb_generic_error_t%s **e  /**< */);', spacing3, spacing2)
     _c('%sxcb_generic_error_t%s **e  /**< */)', spacing3, spacing2)
     _c('{')
-    
+
     if len(unserialize_fields)>0:
         # certain variable size fields need to be unserialized explicitly
-        _c('    %s *reply = (%s *) xcb_wait_for_reply(c, cookie.sequence, e);', 
+        _c('    %s *reply = (%s *) xcb_wait_for_reply(c, cookie.sequence, e);',
            self.c_reply_type, self.c_reply_type)
         _c('    int i;')
         for field in unserialize_fields:
@@ -2259,13 +2259,13 @@  def _c_reply(self, name):
             if field.type.is_list:
                 _c('    for(i=0; i<%s_len; i++) {', field.c_field_name)
                 _c('        %s_data = %s_iter.data;', field.c_field_name, field.c_field_name)
-                _c('        %s((const void *)%s_data, &%s_data);', field.type.c_unserialize_name, 
+                _c('        %s((const void *)%s_data, &%s_data);', field.type.c_unserialize_name,
                    field.c_field_name, field.c_field_name)
                 _c('        %s(&%s_iter);', field.type.c_next_name, field.c_field_name)
                 _c('    }')
         # return the transformed reply
         _c('    return reply;')
-    
+
     else:
         _c('    return (%s *) xcb_wait_for_reply(c, cookie.sequence, e);', self.c_reply_type)
 
@@ -2310,11 +2310,11 @@  def _c_reply_fds(self, name):
     _h('%s%s  *reply  /**< */);', spacing3, self.c_reply_type)
     _c('%s%s  *reply  /**< */)', spacing3, self.c_reply_type)
     _c('{')
-    
+
     _c('    return xcb_get_reply_fds(c, reply, sizeof(%s) + 4 * reply->length);', self.c_reply_type)
 
     _c('}')
-    
+
 
 def _c_opcode(name, opcode):
     '''
@@ -2324,7 +2324,7 @@  def _c_opcode(name, opcode):
     _h('')
     _h('/** Opcode for %s. */', _n(name))
     _h('#define %s %s', _n(name).upper(), opcode)
-    
+
 def _c_cookie(self, name):
     '''
     Declares the cookie type for a non-void request.
@@ -2971,7 +2971,7 @@  output = {'open'    : c_open,
           'union'   : c_union,
           'request' : c_request,
           'event'   : c_event,
-          'error'   : c_error, 
+          'error'   : c_error,
           }
 
 # Boilerplate below this point