X-Git-Url: http://git.demorecorder.com/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fc_client.py;h=87f268b61998dd9ec7f4d26c4e31b030fb8c3258;hb=c4e40f646b8da4fd112ea54a612c880be5e942a8;hp=df2ed11f924a6eb70aa06afbef0ee188b3a54e8d;hpb=cae2e398563841c5b814596fd1f1c64354dcac71;p=free-sw%2Fxcb%2Flibxcb diff --git a/src/c_client.py b/src/c_client.py index df2ed11..87f268b 100644 --- a/src/c_client.py +++ b/src/c_client.py @@ -202,7 +202,7 @@ def c_open(self): _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('') #XXX _h('extern xcb_extension_t %s;', _ns.c_ext_global_name) _c('') @@ -358,7 +358,7 @@ def _c_type_setup(self, name, postfix): field.c_pointer = '*' field.c_field_const_type = 'const ' + field.c_field_type self.c_need_aux = True - elif not field.type.fixed_size() and not field.type.is_bitcase: + elif not field.type.fixed_size() and not field.type.is_case_or_bitcase: self.c_need_sizeof = True field.c_iterator_type = _t(field.field_type + ('iterator',)) # xcb_fieldtype_iterator_t @@ -407,7 +407,7 @@ def _c_type_setup(self, name, postfix): # no list with switch as element, so no call to # _c_iterator(field.type, field_name) necessary - if not self.is_bitcase: + 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) @@ -437,7 +437,7 @@ def _c_helper_absolute_name(prefix, field=None): prefix_str += name if '' == sep: sep = '->' - if ((obj.is_bitcase and obj.has_name) or # named bitcase + if ((obj.is_case_or_bitcase and obj.has_name) or # named bitcase (obj.is_switch and len(obj.parents)>1)): sep = '.' prefix_str += sep @@ -470,7 +470,7 @@ def _c_helper_field_mapping(complex_type, prefix, flat=False): all_fields[f.field_name] = (fname, f) if f.type.is_container and flat==False: - if f.type.is_bitcase and not f.type.has_name: + 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 @@ -493,10 +493,10 @@ def _c_helper_resolve_field_names (prefix): name, sep, obj = p if ''==sep: # sep can be preset in prefix, if not, make a sensible guess - sep = '.' if (obj.is_switch or obj.is_bitcase) else '->' + 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_bitcase or (obj.is_bitcase and obj.has_name): + 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)) @@ -689,18 +689,29 @@ def _c_serialize_helper_switch(context, self, complex_name, 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 in the if len_expr == 1: - code_lines.append(' if(%s & %s) {' % (switch_expr, bitcase_expr)) + code_lines.append( + ' if(%s %s %s) {' % (switch_expr, compare_operator, bitcase_expr)) # multiple in the elif n == 0: # first - code_lines.append(' if((%s & %s) ||' % (switch_expr, bitcase_expr)) + code_lines.append( + ' if((%s %s %s) ||' % (switch_expr, compare_operator, bitcase_expr)) elif len_expr == (n + 1): # last - code_lines.append(' (%s & %s)) {' % (switch_expr, bitcase_expr)) + code_lines.append( + ' (%s %s %s)) {' % (switch_expr, compare_operator, bitcase_expr)) else: # between first and last - code_lines.append(' (%s & %s) ||' % (switch_expr, bitcase_expr)) + code_lines.append( + ' (%s %s %s) ||' % (switch_expr, compare_operator, bitcase_expr)) b_prefix = prefix if b.type.has_name: @@ -710,7 +721,7 @@ def _c_serialize_helper_switch(context, self, complex_name, code_lines, temp_vars, "%s " % space, b_prefix, - is_bitcase = True) + is_case_or_bitcase = True) code_lines.append(' }') # if 'serialize' == context: @@ -834,7 +845,7 @@ 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: + if not self.is_case_or_bitcase: code_lines.append('%s /* %s.%s */' % (space, self.c_type, field.c_field_name)) else: scoped_name = [p[2].c_type if idx==0 else p[0] for idx, p in enumerate(prefix)] @@ -951,7 +962,7 @@ def _c_serialize_helper_fields_variable_size(context, self, field, def _c_serialize_helper_fields(context, self, code_lines, temp_vars, - space, prefix, is_bitcase): + space, prefix, is_case_or_bitcase): count = 0 need_padding = False prev_field_was_variable = False @@ -963,7 +974,7 @@ 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 or self.c_var_followed_by_fixed_fields: + if self.is_case_or_bitcase or self.c_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, @@ -989,7 +1000,7 @@ def _c_serialize_helper_fields(context, self, continue else: # switch/bitcase: always calculate padding before and after variable sized fields - if need_padding or is_bitcase: + if need_padding or is_case_or_bitcase: count += _c_serialize_helper_insert_padding(context, code_lines, space, self.c_var_followed_by_fixed_fields) @@ -1003,7 +1014,7 @@ def _c_serialize_helper_fields(context, self, code_lines.append('%s%s' % (space, value)) if field.type.fixed_size(): - if is_bitcase or self.c_var_followed_by_fixed_fields: + if is_case_or_bitcase or self.c_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'): @@ -1320,16 +1331,6 @@ def _c_iterator(self, name): _h(' * element. The member index is increased by sizeof(%s)', self.c_type) _h(' */') _c('') - _hc('') - _hc('/*****************************************************************************') - _hc(' **') - _hc(' ** void %s', self.c_next_name) - _hc(' ** ') - _hc(' ** @param %s *i', self.c_iterator_type) - _hc(' ** @returns void') - _hc(' **') - _hc(' *****************************************************************************/') - _hc(' ') _hc('void') _h('%s (%s *i /**< */);', self.c_next_name, self.c_iterator_type) _c('%s (%s *i /**< */)', self.c_next_name, self.c_iterator_type) @@ -1371,16 +1372,6 @@ def _c_iterator(self, name): _h(' * last element.') _h(' */') _c('') - _hc('') - _hc('/*****************************************************************************') - _hc(' **') - _hc(' ** xcb_generic_iterator_t %s', self.c_end_name) - _hc(' ** ') - _hc(' ** @param %s i', self.c_iterator_type) - _hc(' ** @returns xcb_generic_iterator_t') - _hc(' **') - _hc(' *****************************************************************************/') - _hc(' ') _hc('xcb_generic_iterator_t') _h('%s (%s i /**< */);', self.c_end_name, self.c_iterator_type) _c('%s (%s i /**< */)', self.c_end_name, self.c_iterator_type) @@ -1481,23 +1472,13 @@ def _c_accessors_field(self, field): # special case: switch switch_obj = self if self.is_switch else None - if self.is_bitcase: + if self.is_case_or_bitcase: switch_obj = self.parents[-1] if switch_obj is not None: c_type = switch_obj.c_type if field.type.is_simple: _hc('') - _hc('') - _hc('/*****************************************************************************') - _hc(' ** ') - _hc(' ** %s %s', field.c_field_type, field.c_accessor_name) - _hc(' ** ') - _hc(' ** @param const %s *R', c_type) - _hc(' ** @returns %s', field.c_field_type) - _hc(' **') - _hc(' *****************************************************************************/') - _hc(' ') _hc('%s', field.c_field_type) _h('%s (const %s *R /**< */);', field.c_accessor_name, c_type) _c('%s (const %s *R /**< */)', field.c_accessor_name, c_type) @@ -1511,16 +1492,6 @@ def _c_accessors_field(self, field): _c('}') else: _hc('') - _hc('') - _hc('/*****************************************************************************') - _hc(' **') - _hc(' ** %s * %s', field.c_field_type, field.c_accessor_name) - _hc(' ** ') - _hc(' ** @param const %s *R', c_type) - _hc(' ** @returns %s *', field.c_field_type) - _hc(' **') - _hc(' *****************************************************************************/') - _hc(' ') if field.type.is_switch and switch_obj is None: return_type = 'void *' else: @@ -1569,7 +1540,7 @@ def _c_accessors_list(self, field): # 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: + if self.is_case_or_bitcase: switch_obj = self.parents[-1] if switch_obj is not None: c_type = switch_obj.c_type @@ -1601,7 +1572,7 @@ def _c_accessors_list(self, field): for p in parents[2:] + [self]: # 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): + if not p.is_case_or_bitcase or (p.is_case_or_bitcase and p.has_name): prefix.append((p.name[-1], '.', p)) fields.update(_c_helper_field_mapping(p, prefix, flat=True)) @@ -1613,16 +1584,6 @@ def _c_accessors_list(self, field): if list.member.fixed_size(): idx = 1 if switch_obj is not None else 0 _hc('') - _hc('') - _hc('/*****************************************************************************') - _hc(' **') - _hc(' ** %s * %s', field.c_field_type, field.c_accessor_name) - _hc(' ** ') - _hc(' ** @param %s', params[idx][0]) - _hc(' ** @returns %s *', field.c_field_type) - _hc(' **') - _hc(' *****************************************************************************/') - _hc(' ') _hc('%s *', field.c_field_type) _h('%s (%s /**< */);', field.c_accessor_name, params[idx][0]) @@ -1647,16 +1608,6 @@ def _c_accessors_list(self, field): _c('}') _hc('') - _hc('') - _hc('/*****************************************************************************') - _hc(' **') - _hc(' ** int %s', field.c_length_name) - _hc(' ** ') - _hc(' ** @param const %s *R', c_type) - _hc(' ** @returns int') - _hc(' **') - _hc(' *****************************************************************************/') - _hc(' ') _hc('int') if switch_obj is not None: _hc('%s (const %s *R /**< */,', field.c_length_name, R_obj.c_type) @@ -1674,16 +1625,6 @@ def _c_accessors_list(self, field): if field.type.member.is_simple: _hc('') - _hc('') - _hc('/*****************************************************************************') - _hc(' **') - _hc(' ** xcb_generic_iterator_t %s', field.c_end_name) - _hc(' ** ') - _hc(' ** @param const %s *R', c_type) - _hc(' ** @returns xcb_generic_iterator_t') - _hc(' **') - _hc(' *****************************************************************************/') - _hc(' ') _hc('xcb_generic_iterator_t') if switch_obj is not None: _hc('%s (const %s *R /**< */,', field.c_end_name, R_obj.c_type) @@ -1716,17 +1657,6 @@ def _c_accessors_list(self, field): else: _hc('') - _hc('') - _hc('/*****************************************************************************') - _hc(' **') - _hc(' ** %s %s', field.c_iterator_type, field.c_iterator_name) - _hc(' ** ') - _hc(' ** @param const %s *R', c_type) - _hc(' ** @returns %s', field.c_iterator_type) - _hc(' **') - _hc(' *****************************************************************************/') - _hc(' ') - _hc('%s', field.c_iterator_type) if switch_obj is not None: _hc('%s (const %s *R /**< */,', field.c_iterator_name, R_obj.c_type) @@ -1997,7 +1927,7 @@ def _c_request_helper(self, name, cookie_type, void, regular, aux=False, reply_f _h(' * No description yet') else: _h(' * Delivers a request to the X server.') - _h(' * ') + _h(' *') if checked: _h(' * This form can be used only if the request will not cause') _h(' * a reply to be generated. Any returned error will be') @@ -2008,26 +1938,6 @@ def _c_request_helper(self, name, cookie_type, void, regular, aux=False, reply_f _h(' * placed in the event queue.') _h(' */') _c('') - _hc('') - _hc('/*****************************************************************************') - _hc(' **') - _hc(' ** %s %s', cookie_type, func_name) - _hc(' ** ') - - spacing = ' ' * (maxtypelen - len('xcb_connection_t')) - _hc(' ** @param xcb_connection_t%s *c', spacing) - - for field in param_fields: - c_field_const_type = field.c_field_const_type - if field.type.c_need_serialize and not aux: - c_field_const_type = "const void" - spacing = ' ' * (maxtypelen - len(c_field_const_type)) - _hc(' ** @param %s%s %s%s', c_field_const_type, spacing, field.c_pointer, field.c_field_name) - - _hc(' ** @returns %s', cookie_type) - _hc(' **') - _hc(' *****************************************************************************/') - _hc(' ') _hc('%s', cookie_type) spacing = ' ' * (maxtypelen - len('xcb_connection_t')) @@ -2070,7 +1980,7 @@ def _c_request_helper(self, name, cookie_type, void, regular, aux=False, reply_f _c(' /* opcode */ %s,', self.c_request_name.upper()) _c(' /* isvoid */ %d', 1 if void else 0) _c(' };') - _c(' ') + _c('') _c(' struct iovec xcb_parts[%d];', dimension) _c(' %s xcb_ret;', func_cookie) @@ -2087,7 +1997,7 @@ def _c_request_helper(self, name, cookie_type, void, regular, aux=False, reply_f _c(' unsigned int i;') _c(' unsigned int xcb_tmp_len;') _c(' char *xcb_tmp;') - _c(' ') + _c('') # simple request call tracing # _c(' printf("in function %s\\n");' % func_name) @@ -2116,7 +2026,7 @@ def _c_request_helper(self, name, cookie_type, void, regular, aux=False, reply_f # calls in order to free dyn. all. memory free_calls = [] - _c(' ') + _c('') if not self.c_var_followed_by_fixed_fields: _c(' xcb_parts[2].iov_base = (char *) &xcb_out;') _c(' xcb_parts[2].iov_len = sizeof(xcb_out);') @@ -2157,7 +2067,7 @@ def _c_request_helper(self, name, cookie_type, void, regular, aux=False, reply_f idx = serial_fields.index(field) aux_var = '&xcb_aux%d' % idx context = 'serialize' if aux else 'sizeof' - _c(' xcb_parts[%d].iov_len = ', count) + _c(' xcb_parts[%d].iov_len =', count) if aux: serialize_args = get_serialize_args(field.type, aux_var, field.c_field_name, context) _c(' %s (%s);', field.type.c_serialize_name, serialize_args) @@ -2189,7 +2099,7 @@ def _c_request_helper(self, name, cookie_type, void, regular, aux=False, reply_f free_calls.append(' free(xcb_aux);') # no padding necessary - _serialize() keeps track of padding automatically - _c(' ') + _c('') for field in param_fields: if field.isfd: _c(' xcb_send_fd(c, %s);', field.c_field_name) @@ -2240,7 +2150,7 @@ def _c_reply(self, name): _h(' * @param e The xcb_generic_error_t supplied') _h(' *') _h(' * Returns the reply of the request asked by') - _h(' * ') + _h(' *') _h(' * The parameter @p e supplied to this function must be NULL if') _h(' * %s(). is used.', self.c_unchecked_name) _h(' * Otherwise, it stores the error if any.') @@ -2248,18 +2158,6 @@ def _c_reply(self, name): _h(' * The returned value must be freed by the caller using free().') _h(' */') _c('') - _hc('') - _hc('/*****************************************************************************') - _hc(' **') - _hc(' ** %s * %s', self.c_reply_type, self.c_reply_name) - _hc(' ** ') - _hc(' ** @param xcb_connection_t%s *c', spacing1) - _hc(' ** @param %s cookie', self.c_cookie_type) - _hc(' ** @param xcb_generic_error_t%s **e', spacing2) - _hc(' ** @returns %s *', self.c_reply_type) - _hc(' **') - _hc(' *****************************************************************************/') - _hc(' ') _hc('%s *', self.c_reply_type) _hc('%s (xcb_connection_t%s *c /**< */,', self.c_reply_name, spacing1) _hc('%s%s cookie /**< */,', spacing3, self.c_cookie_type) @@ -2316,21 +2214,10 @@ def _c_reply_fds(self, name): _h(' * @param reply The reply') _h(' *') _h(' * Returns the array of reply fds of the request asked by') - _h(' * ') + _h(' *') _h(' * The returned value must be freed by the caller using free().') _h(' */') _c('') - _hc('') - _hc('/*****************************************************************************') - _hc(' **') - _hc(' ** int * %s', self.c_reply_fds_name) - _hc(' ** ') - _hc(' ** @param xcb_connection_t%s *c', spacing1) - _hc(' ** @param %s *reply', self.c_reply_type) - _hc(' ** @returns int *') - _hc(' **') - _hc(' *****************************************************************************/') - _hc(' ') _hc('int *') _hc('%s (xcb_connection_t%s *c /**< */,', self.c_reply_fds_name, spacing1) _h('%s%s *reply /**< */);', spacing3, self.c_reply_type) @@ -2488,7 +2375,7 @@ def _man_request(self, name, cookie_type, void, aux): # special case: switch switch_obj = self if self.is_switch else None - if self.is_bitcase: + if self.is_case_or_bitcase: switch_obj = self.parents[-1] if switch_obj is not None: c_type = switch_obj.c_type @@ -2516,7 +2403,7 @@ def _man_request(self, name, cookie_type, void, aux): # 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: + if self.is_case_or_bitcase: switch_obj = self.parents[-1] if switch_obj is not None: c_type = switch_obj.c_type @@ -2548,7 +2435,7 @@ def _man_request(self, name, cookie_type, void, aux): for p in parents[2:] + [self]: # 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): + if not p.is_case_or_bitcase or (p.is_case_or_bitcase and p.has_name): prefix.append((p.name[-1], '.', p)) fields.update(_c_helper_field_mapping(p, prefix, flat=True))