From: Christoph Reimann Date: Mon, 2 Aug 2010 21:30:42 +0000 (+0200) Subject: attempt to fix special case: variable fields followed by fixed size fields X-Git-Tag: 1.8.1~40^2~3^2~6^2~5 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=b187f029d6bb693f0294bad5261ec486b140f185;p=profile%2Fivi%2Flibxcb.git attempt to fix special case: variable fields followed by fixed size fields --- diff --git a/src/c_client.py b/src/c_client.py index bd502b3..3e8f9c6 100644 --- a/src/c_client.py +++ b/src/c_client.py @@ -287,10 +287,10 @@ def _c_type_setup(self, name, postfix): self.c_aux_unchecked_name = _n(name + ('aux', 'unchecked')) self.c_serialize_name = _n(name + ('serialize',)) self.c_unserialize_name = _n(name + ('unserialize',)) - if hasattr(self, 'reply'): - if self.reply is not None: - self.c_serialize_name = _n(name + ('reply', 'serialize')) - self.c_unserialize_name = _n(name + ('reply', 'unserialize')) +# if hasattr(self, 'reply'): +# if self.reply is not None: +# self.c_serialize_name = _n(name + ('reply', 'serialize')) +# self.c_unserialize_name = _n(name + ('reply', 'unserialize')) # indicates rare structs where variable size fields are followed fixed size fields self.var_followed_by_fixed_fields = False @@ -335,7 +335,10 @@ def _c_type_setup(self, name, postfix): 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 + # special case - c_field_name ends with _length as well + # if field.c_accessor_name.endswith('_length'): + # raise Exception(field.c_field_name) #if field.c_field_name.endswith('length'): # c_field_name = field.c_field_name.rsplit('length', 1) # field.c_field_name = c_field_name[0] + "_length" @@ -354,13 +357,21 @@ def _c_type_setup(self, name, postfix): if not self.is_union: self.need_serialize = True self.var_followed_by_fixed_fields = True -# print "WARNING (%s): variable size field %s followed by fixed size field %s" % ( -# self.c_type, prev_varsized_field.field_name, field.field_name) else: self.last_varsized_field = field prev_varsized_field = field prev_varsized_offset = 0 + # very special case - if self.var_followed_by_fixed_fields==True, + # we have to generate accessor functions also for fixed size fields + # now there might a naming conflict if the length field ends with _length + if self.var_followed_by_fixed_fields: + if field.type.is_list: + if field.type.expr.lenfield_name is not None: + full_lenfield_name = _n(name + (field.type.expr.lenfield_name,)) + if full_lenfield_name == field.c_length_name: + field.c_length_name += '_' + # as switch does never appear at toplevel, # continue here with type construction if self.is_switch: @@ -510,9 +521,11 @@ def _c_serialize_helper_prefix(prefix): # prefix is a list of (field_name, anchestor object) tuples # concatenate field names prefix_str = '' - for name, obj in prefix: + for name, sep, obj in prefix: prefix_str += name - prefix_str += '.' if (obj.is_bitcase and obj.has_name) else '->' + if sep == '': + sep = '.' if (obj.is_bitcase and obj.has_name) else '->' + prefix_str += sep lenfield_prefix = '' if prefix_str.find('_aux')==0 else "_aux" if prefix_str != '': if lenfield_prefix != '': @@ -543,7 +556,7 @@ def _c_field_mapping(context, complex_type, prefix): raise Exception("field name %s has been registered before" % f.field_name) fields[f.field_name] = (fname, f) if f.type.is_container: - get_field_name(fields, f.type, prefix+[(f.c_field_name, f.type)]) + get_field_name(fields, f.type, prefix+[(f.c_field_name, '', f.type)]) # get_field_name() # dict(field_name : (c_field_name, field)) @@ -584,7 +597,7 @@ def _c_serialize_helper_switch(context, self, complex_name, code_lines, temp_vars, space, prefix): count = 0 - switch_prefix = prefix + [(complex_name, self)] + switch_prefix = prefix + [(complex_name, '->', self)] prefix_str, lenfield_prefix = _c_serialize_helper_prefix(switch_prefix) switch_expr = _c_accessor_get_expr(self.expr) @@ -593,7 +606,7 @@ def _c_serialize_helper_switch(context, self, complex_name, code_lines.append(' if(%s & %s) {' % (switch_expr, bitcase_expr)) b_prefix = switch_prefix if b.type.has_name: - b_prefix = switch_prefix + [(b.c_field_name, b.type)] + b_prefix = switch_prefix + [(b.c_field_name, '.', b.type)] _c_serialize_helper_fields(context, b.type, code_lines, temp_vars, "%s " % space, @@ -773,6 +786,7 @@ def _c_serialize_helper_fields(context, self, space, prefix, is_bitcase): count = 0 need_padding = False + prev_field_was_variable = False for field in self.fields: if not ((field.wire and not field.auto) or field.visible): @@ -780,10 +794,17 @@ def _c_serialize_helper_fields(context, self, # switch/bitcase: fixed size fields must be considered explicitly if field.type.fixed_size(): - if self.is_bitcase: + if self.is_bitcase or self.var_followed_by_fixed_fields: + if prev_field_was_variable and need_padding: + # insert padding + _c_serialize_helper_insert_padding(context, code_lines, space) + prev_field_was_variable = False + fixed_prefix = prefix + if self.var_followed_by_fixed_fields and len(prefix)==0: + fixed_prefix = [('_aux', '->', self)] value, length = _c_serialize_helper_fields_fixed_size(context, self, field, code_lines, temp_vars, - space, prefix) + space, fixed_prefix) else: continue @@ -796,6 +817,7 @@ def _c_serialize_helper_fields(context, self, value, length = _c_serialize_helper_fields_variable_size(context, self, field, code_lines, temp_vars, space, prefix) + prev_field_was_variable = True # save (un)serialization C code if '' != value: @@ -840,7 +862,7 @@ def _c_serialize_helper(context, complex_type, # all other data types can be evaluated one field a time else: # unserialize & fixed size fields: simply cast the buffer to the respective xcb_out type - if 'unserialize' == context: + if 'unserialize' == context and not self.var_followed_by_fixed_fields: code_lines.append('%s xcb_block_len += sizeof(%s);' % (space, self.c_type)) code_lines.append('%s xcb_tmp += xcb_block_len;' % space) _c_serialize_helper_insert_padding(context, code_lines, space) @@ -1002,7 +1024,10 @@ def _c_unserialize(self): _c('{') _c(' char *xcb_tmp = (char *)_buffer;') if not self.is_switch: - _c(' const %s *_aux = (%s *)_buffer;', self.c_type, self.c_type) + if not self.var_followed_by_fixed_fields: + _c(' const %s *_aux = (%s *)_buffer;', self.c_type, self.c_type) + else: + _c(' %s *_aux = malloc(sizeof(%s));', self.c_type, self.c_type) _c(' unsigned int xcb_buffer_len = 0;') _c(' unsigned int xcb_block_len = 0;') _c(' unsigned int xcb_pad = 0;') @@ -1018,6 +1043,10 @@ def _c_unserialize(self): for l in code_lines: _c(l) _c('') + if not self.is_switch: + if self.var_followed_by_fixed_fields: + _c(' free(_aux);') + _c(' return xcb_buffer_len;') _c('}') # _c_unserialize() @@ -1030,8 +1059,6 @@ def _c_iterator_get_end(field, accum): ''' if field.type.is_container: accum = field.c_accessor_name + '(' + accum + ')' - if field.type.fixed_size(): - print "iterator_get_end()", accum, field.c_field_name # XXX there could be fixed-length fields at the end return _c_iterator_get_end(field.type.last_varsized_field, accum) if field.type.is_list: @@ -1085,10 +1112,14 @@ def _c_iterator(self, name): if not self.fixed_size(): _c(' %s *R = i->data;', self.c_type) - _c(' xcb_generic_iterator_t child = %s;', _c_iterator_get_end(self.last_varsized_field, 'R')) - _c(' --i->rem;') - _c(' i->data = (%s *) child.data;', self.c_type) - _c(' i->index = child.index;') + 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) + else: + _c(' xcb_generic_iterator_t child = %s;', _c_iterator_get_end(self.last_varsized_field, 'R')) + _c(' --i->rem;') + _c(' i->data = (%s *) child.data;', self.c_type) + _c(' i->index = child.index;') else: _c(' --i->rem;') _c(' ++i->data;') @@ -1412,16 +1443,16 @@ def _c_complex(self): varfield = None for field in self.fields: - if not field.type.fixed_size() and not self.is_switch: + if not field.type.fixed_size() and not self.is_switch and not self.is_union: varfield = field.c_field_name continue - if varfield != None and not field.type.is_pad and field.wire: - errmsg = '%s: warning: variable field %s followed by fixed field %s\n' % (self.c_type, varfield, field.c_field_name) - sys.stderr.write(errmsg) - # sys.exit(1) +# if varfield != None and not field.type.is_pad and field.wire: +# errmsg = '%s: warning: variable field %s followed by fixed field %s\n' % (self.c_type, varfield, field.c_field_name) +# sys.stderr.write(errmsg) +# sys.exit(1) if field.wire: struct_fields.append(field) - + for field in struct_fields: length = len(field.c_field_type) # account for '*' pointer_spec @@ -1600,14 +1631,16 @@ def _c_request_helper(self, name, cookie_type, void, regular, aux=False): spacing, c_pointer, field.c_field_name, comma) count = 2 - if self.var_followed_by_fixed_fields: - count += len(wire_fields)*2 - for field in param_fields: - if not field.type.fixed_size(): - count = count + 2 - if field.type.need_serialize: - # _serialize() keeps track of padding automatically - count -= 1 + if not self.var_followed_by_fixed_fields: + for field in param_fields: + if not field.type.fixed_size(): + count = count + 2 + if field.type.need_serialize: + # _serialize() keeps track of padding automatically + count -= 1 + else: + # there will be only one call to _serialize() and no need for additional padding + count -= 1 _c('{') _c(' static const xcb_protocol_request_t xcb_req = {') @@ -1620,8 +1653,10 @@ def _c_request_helper(self, name, cookie_type, void, regular, aux=False): _c(' struct iovec xcb_parts[%d];', count + 2) _c(' %s xcb_ret;', func_cookie) - if not self.var_followed_by_fixed_fields: - _c(' %s xcb_out;', self.c_type) + _c(' %s xcb_out;', self.c_type) + if self.var_followed_by_fixed_fields: + _c(' /* in the protocol description, variable size fields are followed by fixed size fields */') + for idx, f in enumerate(serial_fields): if not aux: @@ -1629,84 +1664,90 @@ def _c_request_helper(self, name, cookie_type, void, regular, aux=False): else: _c(' void *xcb_aux%d = 0;' % (idx)) _c(' ') -# _c(' printf("in function %s\\n");' % func_name) + _c(' printf("in function %s\\n");' % func_name) # fixed size fields - if not self.var_followed_by_fixed_fields: - for field in wire_fields: - if field.type.fixed_size(): - if field.type.is_expr: - _c(' xcb_out.%s = %s;', field.c_field_name, _c_accessor_get_expr(field.type.expr)) - elif field.type.is_pad: - if field.type.nmemb == 1: - _c(' xcb_out.%s = 0;', field.c_field_name) - else: - _c(' memset(xcb_out.%s, 0, %d);', field.c_field_name, field.type.nmemb) + for field in wire_fields: + if field.type.fixed_size(): + if field.type.is_expr: + _c(' xcb_out.%s = %s;', field.c_field_name, _c_accessor_get_expr(field.type.expr)) + elif field.type.is_pad: + if field.type.nmemb == 1: + _c(' xcb_out.%s = 0;', field.c_field_name) else: - if field.type.nmemb == 1: - _c(' xcb_out.%s = %s;', field.c_field_name, field.c_field_name) - else: - _c(' memcpy(xcb_out.%s, %s, %d);', field.c_field_name, field.c_field_name, field.type.nmemb) + _c(' memset(xcb_out.%s, 0, %d);', field.c_field_name, field.type.nmemb) + else: + if field.type.nmemb == 1: + _c(' xcb_out.%s = %s;', field.c_field_name, field.c_field_name) + else: + _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, unserialize=False): + if unserialize: + serialize_args = get_serialize_params('unserialize', type_obj, + c_field_name, + aux_var)[2] + else: + serialize_args = get_serialize_params('serialize', type_obj, + aux_var, + c_field_name)[2] + serialize_args = reduce(lambda x,y: "%s, %s" % (x,y), [a[2] for a in serialize_args]) + return serialize_args + # calls in order to free dyn. all. memory + free_calls = [] + + if not self.var_followed_by_fixed_fields: _c(' ') _c(' xcb_parts[2].iov_base = (char *) &xcb_out;') _c(' xcb_parts[2].iov_len = sizeof(xcb_out);') _c(' xcb_parts[3].iov_base = 0;') _c(' xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;') - # calls in order to free dyn. all. memory - free_calls = [] - if not self.var_followed_by_fixed_fields: count = 4 - else: - count = 2 - var_size_fields = param_fields - if self.var_followed_by_fixed_fields: - var_size_fields = wire_fields + param_fields - for field in var_size_fields: - if field.type.fixed_size and self.var_followed_by_fixed_fields: - _c(' xcb_parts[%d].iov_base = (char *) &%s;', count, field.c_field_name) - _c(' xcb_parts[%d].iov_len = sizeof(%s);', count, field.type.c_type) - count += 1 - if not field.type.fixed_size(): - # default: simple cast to char * - if not field.type.need_serialize: - _c(' xcb_parts[%d].iov_base = (char *) %s;', count, field.c_field_name) - if field.type.is_list: - _c(' xcb_parts[%d].iov_len = %s * sizeof(%s);', count, - _c_accessor_get_expr(field.type.expr), field.type.member.c_wiretype) - else: - # not supposed to happen - raise Exception("unhandled variable size field %s" % field.c_field_name) - #_c('/* eeeeeeeeeee */') - else: - if not aux: + + for field in param_fields: + if not field.type.fixed_size(): + _c(' /* %s %s */', field.type.c_type, field.c_field_name) + # default: simple cast to char * + if not field.type.need_serialize: _c(' xcb_parts[%d].iov_base = (char *) %s;', count, field.c_field_name) - idx = serial_fields.index(field) - if not aux: - serialize_args = get_serialize_params('unserialize', field.type, - field.c_field_name, - '&xcb_aux%d' % idx)[2] - else: - serialize_args = get_serialize_params('serialize', field.type, - '&xcb_aux%d' % idx, - field.c_field_name)[2] - serialize_args = reduce(lambda x,y: "%s, %s" % (x,y), [a[2] for a in serialize_args]) - _c(' xcb_parts[%d].iov_len = ', count) - if aux: - _c(' %s (%s);', field.type.c_serialize_name, serialize_args) - _c(' xcb_parts[%d].iov_base = xcb_aux%d;' % (count, idx)) - free_calls.append(' free(xcb_aux%d);' % idx) + if field.type.is_list: + _c(' xcb_parts[%d].iov_len = %s * sizeof(%s);', count, + _c_accessor_get_expr(field.type.expr), field.type.member.c_wiretype) + else: + # not supposed to happen + raise Exception("unhandled variable size field %s" % field.c_field_name) else: - _c(' %s (%s);', field.type.c_unserialize_name, serialize_args) + if not aux: + _c(' xcb_parts[%d].iov_base = (char *) %s;', count, field.c_field_name) + idx = serial_fields.index(field) + aux_var = '&xcb_aux%d' % idx + serialize_args = get_serialize_args(field.type, field.c_field_name, aux_var, not aux) + _c(' xcb_parts[%d].iov_len = ', count) + if aux: + _c(' %s (%s);', field.type.c_serialize_name, serialize_args) + _c(' xcb_parts[%d].iov_base = xcb_aux%d;' % (count, idx)) + free_calls.append(' free(xcb_aux%d);' % idx) + else: + _c(' %s (%s);', field.type.c_unserialize_name, serialize_args) - - count += 1 - if not field.type.need_serialize: - # the _serialize() function keeps track of padding automatically - _c(' xcb_parts[%d].iov_base = 0;', count) - _c(' xcb_parts[%d].iov_len = -xcb_parts[%d].iov_len & 3;', count, count-1) count += 1 + if not field.type.need_serialize: + # the _serialize() function keeps track of padding automatically + _c(' xcb_parts[%d].iov_base = 0;', count) + _c(' xcb_parts[%d].iov_len = -xcb_parts[%d].iov_len & 3;', count, count-1) + count += 1 + + # elif self.var_followed_by_fixed_fields: + else: + # call _serialize() + buffer_var = 'xcb_parts[%d].iov_base' % count + serialize_args = get_serialize_args(self, '&xcb_out', '&%s' % buffer_var, False) + _c(' %s = (char *) 0;', buffer_var) + _c(' xcb_parts[%d].iov_len = %s (%s);', count, self.c_serialize_name, serialize_args) + free_calls.append(' free(xcb_parts[%d].iov_base);' % count) + # no padding necessary - _serialize() keeps track of padding automatically _c(' ') _c(' xcb_ret.sequence = xcb_send_request(c, %s, xcb_parts + 2, &xcb_req);', func_flags)