def make_object_class_inline(self, is_connection, class_name=""):
member = ""
method_name = self.name
if not is_connection:
member = "resource(),\n"
method_name = replace_class(method_name, class_name)
if self.is_void:
return _inline_void_class(self.request_name, method_name, member, get_namespace(self.namespace))
else:
return _inline_reply_class(self.request_name, method_name, member, get_namespace(self.namespace))
def make_object_class_inline(self, is_connection, class_name=""):
member = ""
method_name = self.name
if not is_connection:
member = "resource(),\n"
method_name = replace_class(method_name, class_name)
if self.is_void:
return _inline_void_class(self.request_name, method_name, member,
get_namespace(self.namespace))
else:
return _inline_reply_class(self.request_name, method_name, member,
get_namespace(self.namespace))
def __init__(self, request, name, is_void, namespace, reply):
self.request = request
self.name = name
self.request_name = _ext(_n_item(self.request.name[-1]))
self.is_void = is_void
self.namespace = namespace
self.reply = reply
self.c_namespace = \
"" if namespace.header.lower() == "xproto" \
else get_namespace(namespace)
self.accessors = []
self.parameter_list = ParameterList()
self.c_name = "xcb" \
+ (("_" + get_namespace(namespace)) if namespace.is_ext else "") \
+ "_" + self.request_name
def make_class(self):
# if not self.namespace.is_ext:
# return ""
# else:
ns = get_namespace(self.namespace)
if self.namespace.is_ext:
base = "\n : public xpp::generic::extension<extension, &xcb_%s_id>\n" % ns
ctor = " using base = xpp::generic::extension<extension, &xcb_%s_id>;\n" % ns + \
" using base::base;\n"
else:
base = " "
ctor = ""
return \
'''\
template<typename Derived, typename Connection>
class interface;
namespace event { template<typename Connection> class dispatcher; };
namespace error { class dispatcher; };
class extension%s{
public:
%s\
template<typename Derived, typename Connection>
using interface = xpp::%s::interface<Derived, Connection>;
template<typename Connection>
using event_dispatcher = xpp::%s::event::dispatcher<Connection>;
using error_dispatcher = xpp::%s::error::dispatcher;
};\
''' % (base,
ctor,
ns, # typedef xpp::interface::%s interface;
ns, # typedef xpp::event::dispatcher::%s dispatcher;
ns) # typedef xpp::error::dispatcher::%s dispatcher;
def __init__(self, request, name, is_void, namespace, reply):
self.request = request
self.name = name
self.request_name = _ext(_n_item(self.request.name[-1]))
self.is_void = is_void
self.namespace = namespace
self.reply = reply
self.c_namespace = \
"" if namespace.header.lower() == "xproto" \
else get_namespace(namespace)
self.accessors = []
self.parameter_list = ParameterList()
self.c_name = "xcb" \
+ (("_" + get_namespace(namespace)) if namespace.is_ext else "") \
+ "_" + self.request_name
def get_abstract_enum(node, tu, scf_path):
enum_constant_nodes = matchers.get_children(node, lambda n: n.kind == CursorKind.ENUM_CONSTANT_DECL)
full_namespace = utils.get_namespace(node)
constants = [generic.EnumConstant(cons.spelling, cons.enum_value) for cons in enum_constant_nodes]
return generic.DefinedEnum(name=node.spelling, namespace=full_namespace, constants=constants, \
defined_in_header=utils.get_header(node, tu, scf_path), \
location=_convert_location(node.location))
def make_class(self):
# if not self.namespace.is_ext:
# return ""
# else:
ns = get_namespace(self.namespace)
if self.namespace.is_ext:
base = "\n : public xpp::generic::extension<extension, &xcb_%s_id>\n" % ns
ctor = " using base = xpp::generic::extension<extension, &xcb_%s_id>;\n" % ns + \
" using base::base;\n"
else:
base = " "
ctor = ""
return \
'''\
template<typename Derived, typename Connection>
class interface;
namespace event { template<typename Connection> class dispatcher; };
namespace error { class dispatcher; };
class extension%s{
public:
%s\
template<typename Derived, typename Connection>
using interface = xpp::%s::interface<Derived, Connection>;
template<typename Connection>
using event_dispatcher = xpp::%s::event::dispatcher<Connection>;
using error_dispatcher = xpp::%s::error::dispatcher;
};\
''' % (base,
ctor,
ns, # typedef xpp::interface::%s interface;
ns, # typedef xpp::event::dispatcher::%s dispatcher;
ns) # typedef xpp::error::dispatcher::%s dispatcher;
def get_abstract_entity(node, tu, scf_path, prev):
ns = utils.get_namespace(node)
full_name = ns + '::' + node.spelling if ns else node.spelling
if any(full_name == p for p in prev):
return generic.RecursiveType(node.spelling, ns)
if node.kind == CursorKind.ENUM_DECL:
return get_abstract_enum(node, tu, scf_path)
else:
return get_abstract_class(node, tu, scf_path, prev)
def __init__(self, namespace, is_void, name, reply, parameter_list):
self.namespace = namespace
self.is_void = is_void
self.name = name
self.reply = reply
self.parameter_list = parameter_list
self.request_name = _ext(_n_item(self.name[-1]))
self.c_name = "xcb" \
+ (("_" + get_namespace(namespace)) if namespace.is_ext else "") \
+ "_" + self.request_name
def __init__(self, namespace, is_void, name, reply, parameter_list):
self.namespace = namespace
self.is_void = is_void
self.name = name
self.reply = reply
self.parameter_list = parameter_list
self.request_name = _ext(_n_item(self.name[-1]))
self.c_name = "xcb" \
+ (("_" + get_namespace(namespace)) if namespace.is_ext else "") \
+ "_" + self.request_name
def get_abstract_class(node, tu, scf_path, prev):
ns = utils.get_namespace(node)
full_name = ns + '::' + node.spelling if ns else node.spelling
base_nodes = matchers.get_children(node, matchers.is_base_class())
base_type_infos = [utils.get_type_info(base_node.type, tu, scf_path) for base_node in base_nodes]
base_classes = [_create_entity_info(base_type.name, base_node.type.spelling, \
def_node, template_class, tu, scf_path, prev + [full_name]) \
for (base_node, (base_type, def_node, template_class)) in zip(base_nodes, base_type_infos)]
field_nodes = matchers.get_children(node, matchers.is_field())
fields = [_get_field_info(field_node, tu, scf_path, prev + [full_name]) for field_node in field_nodes]
api_nodes = matchers.get_children(node, matchers.is_method())
apis = [_get_api(api_node, tu, scf_path, prev + [full_name]) for api_node in api_nodes]
annotation = _get_annotation(node)
template_args = [node.type.get_template_argument_type(i) for i in range(node.type.get_num_template_arguments())]
if template_args:
template_args_entities = [
generic.PrimitiveType(
utils.get_primitive_type(templ_arg)) if utils.is_primitive(templ_arg)
else get_abstract_entity(templ_arg.get_declaration(), tu, scf_path, prev + [full_name])
for templ_arg in template_args]
header = utils.get_header(node, tu, scf_path)
if header or not scf_path:
return generic.DefinedClass(name=node.spelling, namespace=utils.get_namespace(node),
template_args=template_args_entities, members=fields, methods=apis,
bases=base_classes, defined_in_header=header,
location=_convert_location(node.location), annotation=annotation)
else:
return generic.DeclaredClass(node.spelling, utils.get_namespace(node), template_args_entities, None)
else:
type_info, _, _ = utils.get_type_info(node.type, tu, scf_path)
if type_info.header_with_def or not scf_path:
return generic.DefinedClass(name=type_info.name, namespace=type_info.namespace, template_args=[],
members=fields, methods=apis, bases=base_classes,
defined_in_header=type_info.header_with_def,
location=_convert_location(node.location), annotation=annotation)
else:
return generic.DeclaredClass(type_info.name, type_info.namespace, [], None)
def __init__(self, namespace, name, cookie, reply, accessors, parameter_list):
self.namespace = namespace
self.name = name
self.reply = reply
self.cookie = cookie
self.accessors = accessors
self.parameter_list = parameter_list
self.request_name = _ext(_n_item(self.name[-1]))
self.c_name = "xcb" \
+ (("_" + get_namespace(namespace)) if namespace.is_ext else "") \
+ "_" + self.request_name
def error_dispatcher_class(namespace, cpperrors):
ns = get_namespace(namespace)
ctor_name = "dispatcher"
typedef = []
ctors = []
members = []
opcode_switch = "error->error_code"
typedef = [ "typedef xpp::%s::extension extension;\n" % ns ]
# >>> if begin <<<
if namespace.is_ext:
opcode_switch = "error->error_code - m_first_error"
members += \
[ "protected:"
, " uint8_t m_first_error;"
]
ctors = \
[ "%s(uint8_t first_error)" % (ctor_name)
, " : m_first_error(first_error)"
, "{}"
, ""
, "%s(const xpp::%s::extension & extension)" % (ctor_name, ns)
, " : %s(extension->first_error)" % ctor_name
, "{}"
]
# >>> if end <<<
if len(typedef) > 0:
typedef = "\n".join(map(lambda s: " " + s, typedef)) + "\n"
else:
typedef = ""
if len(ctors) > 0:
ctors = "\n".join(map(lambda s: (" " if len(s) > 0 else "") + s, ctors)) + "\n"
else:
ctors = ""
if len(members) > 0:
members = "\n".join(map(lambda s: " " + s, members)) + "\n"
else:
members = ""
switch = error_switch_cases(cpperrors, opcode_switch, "error")
return _error_dispatcher_class(typedef,
ctors,
switch,
members,
len(cpperrors) > 0)
def __init__(self, namespace, name, cookie, reply, accessors, parameter_list):
self.namespace = namespace
self.name = name
self.reply = reply
self.cookie = cookie
self.accessors = accessors
self.parameter_list = parameter_list
self.request_name = _ext(_n_item(self.name[-1]))
self.c_name = "xcb" \
+ (("_" + get_namespace(namespace)) if namespace.is_ext else "") \
+ "_" + self.request_name
def error_dispatcher_class(namespace, cpperrors):
ns = get_namespace(namespace)
ctor_name = "dispatcher"
typedef = []
ctors = []
members = []
opcode_switch = "error->error_code"
typedef = [ "typedef xpp::%s::extension extension;\n" % ns ]
# >>> if begin <<<
if namespace.is_ext:
opcode_switch = "error->error_code - m_first_error"
members += \
[ "protected:"
, " uint8_t m_first_error;"
]
ctors = \
[ "%s(uint8_t first_error)" % (ctor_name)
, " : m_first_error(first_error)"
, "{}"
, ""
, "%s(const xpp::%s::extension & extension)" % (ctor_name, ns)
, " : %s(extension->first_error)" % ctor_name
, "{}"
]
# >>> if end <<<
if len(typedef) > 0:
typedef = "\n".join(map(lambda s: " " + s, typedef)) + "\n"
else:
typedef = ""
if len(ctors) > 0:
ctors = "\n".join(map(lambda s: (" " if len(s) > 0 else "") + s, ctors)) + "\n"
else:
ctors = ""
if len(members) > 0:
members = "\n".join(map(lambda s: " " + s, members)) + "\n"
else:
members = ""
switch = error_switch_cases(cpperrors, opcode_switch, "error")
return _error_dispatcher_class(typedef,
ctors,
switch,
members,
len(cpperrors) > 0)
def make_class(self):
cppcookie = CppCookie(self.namespace, self.is_void, self.request.name, self.reply, self.parameter_list)
if self.is_void:
void_functions = cppcookie.make_void_functions()
if len(void_functions) > 0:
return void_functions
else:
return _void_request_function(get_namespace(self.namespace), self.request_name, self.c_name)
else:
cppreply = CppReply(self.namespace, self.request.name, cppcookie, self.reply, self.accessors, self.parameter_list)
return cppreply.make() + "\n\n" + _reply_request_function(self.request_name)
def void_functions(self, protos, calls, template="", initializer=[]):
inits = "" if len(initializer) > 0 else "\n"
for i in initializer:
inits += "\n"
for line in i.split('\n'):
inits += " " + line + "\n"
return_value = "xcb_void_cookie_t"
return _void_cookie_function(get_namespace(self.namespace),
self.request_name, self.c_name, template,
return_value,
self.comma() + protos,
self.comma() + calls, inits)
def void_functions(self, protos, calls, template="", initializer=[]):
inits = "" if len(initializer) > 0 else "\n"
for i in initializer:
inits += "\n"
for line in i.split('\n'):
inits += " " + line + "\n"
return_value = "xcb_void_cookie_t"
return _void_cookie_function(get_namespace(self.namespace),
self.request_name,
self.c_name,
template,
return_value,
self.comma() + protos,
self.comma() + calls,
inits)
def make_class(self):
cppcookie = CppCookie(self.namespace, self.is_void, self.request.name,
self.reply, self.parameter_list)
if self.is_void:
void_functions = cppcookie.make_void_functions()
if len(void_functions) > 0:
return void_functions
else:
return _void_request_function(get_namespace(self.namespace),
self.request_name, self.c_name)
else:
cppreply = CppReply(self.namespace, self.request.name, cppcookie,
self.reply, self.accessors,
self.parameter_list)
return cppreply.make() + "\n\n" + _reply_request_function(
self.request_name)
def make_proto(self):
ns = get_namespace(self.namespace)
methods = ""
for request in self.requests:
methods += request.make_object_class_inline(True) + "\n\n"
typedef = []
if self.namespace.is_ext:
typedef = ["typedef xpp::%s::extension extension;" % ns]
if len(typedef) > 0:
typedef = "".join([" " + s for s in typedef]) + "\n\n"
else:
typedef = ""
return (_templates['interface_class'] \
% (typedef, ns, methods)) + \
'\n' + event_dispatcher_class(self.namespace, self.events) + \
'\n' + error_dispatcher_class(self.namespace, self.errors)
def make_proto(self):
ns = get_namespace(self.namespace)
methods = ""
for request in self.requests:
methods += request.make_object_class_inline(True) + "\n\n"
typedef = []
if self.namespace.is_ext:
typedef = [ "typedef xpp::%s::extension extension;" % ns ]
if len(typedef) > 0:
typedef = "".join(map(lambda s: " " + s, typedef)) + "\n\n"
else:
typedef = ""
return (_templates['interface_class'] \
% (typedef, ns, methods)) + \
'\n' + event_dispatcher_class(self.namespace, self.events) + \
'\n' + error_dispatcher_class(self.namespace, self.errors)
def make_inline(self):
ns = get_namespace(self.namespace)
name = self.name.lower()
c_name = self.c_name
methods = ""
for request in self.requests:
methods += request.make_object_class_inline(False, self.name.lower()) + "\n\n"
if methods == "":
return ""
else:
return \
"""\
template<typename Derived, typename Connection>
class %s
{
protected:
Connection
connection(void) const
{
return static_cast<const Derived *>(this)->connection();
}
const %s &
resource(void) const
{
return static_cast<const Derived *>(this)->resource();
}
public:
virtual ~%s(void) {}
%s
}; // class %s
""" % (name, # class %s
c_name, # %s resource(void) { ... }
name, # virtual ~%s(void)
methods,
name) # }; // class %s
def make(self):
accessors = [self.make_accessors()]
naccessors = len(self.accessors)
for field in self.reply.fields:
if (field.field_type[-1] in _resource_classes
and not field.type.is_list
and not field.type.is_container):
naccessors = naccessors + 1
name = field.field_name.lower()
c_type = field.c_field_type
template_type = field.field_name.capitalize()
accessors.append(_reply_member_accessor(self.request_name, name, c_type, template_type))
result = ""
result += _reply_class(
self.request_name, self.c_name, get_namespace(self.namespace),
self.cookie, "\n".join(accessors))
return result
def make(self):
accessors = [self.make_accessors()]
naccessors = len(self.accessors)
for field in self.reply.fields:
if (field.field_type[-1] in _resource_classes
and not field.type.is_list
and not field.type.is_container):
naccessors = naccessors + 1
name = field.field_name.lower()
c_type = field.c_field_type
template_type = field.field_name.capitalize()
accessors.append(_reply_member_accessor(self.request_name, name, c_type, template_type))
result = ""
result += _reply_class(
self.request_name, self.c_name, get_namespace(self.namespace),
self.cookie, "\n".join(accessors))
return result
def ns_attributes(self):
prefix_omit = set()
ns_omit = list(self.ns_omit)
root = self.element.getroottree().getroot()
if root is None or utils.get_namespace(root) == config.META_NS:
ns_omit.append("http://www.w3.org/1999/xhtml")
prefix_omit = set()
namespaces = self.element.nsmap.values()
parent = self.element.getparent()
while parent is not None:
for prefix, ns in parent.nsmap.items():
if ns in namespaces:
prefix_omit.add(prefix)
parent = parent.getparent()
attrs = dict(((prefix and "xmlns:%s" % prefix or "xmlns", ns)
for (prefix, ns) in self.element.nsmap.items()
if ns not in ns_omit and prefix not in prefix_omit))
return attrs
def ns_attributes(self):
prefix_omit = set()
ns_omit = list(self.ns_omit)
root = self.element.getroottree().getroot()
if root is None or utils.get_namespace(root) == config.META_NS:
ns_omit.append("http://www.w3.org/1999/xhtml")
prefix_omit = set()
namespaces = self.element.nsmap.values()
parent = self.element.getparent()
while parent is not None:
for prefix, ns in parent.nsmap.items():
if ns in namespaces:
prefix_omit.add(prefix)
parent = parent.getparent()
attrs = dict(
((prefix and "xmlns:%s" % prefix or "xmlns", ns)
for (prefix, ns) in self.element.nsmap.items()
if ns not in ns_omit and prefix not in prefix_omit))
return attrs
def make_class(self):
ns = get_namespace(self.namespace)
typedef = []
members = []
opcode_accessor = \
[ "static uint8_t opcode(void)"
, "{"
, " return %s;" % self.opcode_name
, "}"
]
if self.namespace.is_ext:
opcode_accessor += \
[ ""
, "static uint8_t opcode(uint8_t first_error)"
, "{"
, " return first_error + opcode();"
, "}"
, ""
, "static uint8_t opcode(const xpp::%s::extension & extension)" % ns
, "{"
, " return opcode(extension->first_error);"
, "}"
]
members = \
[ "protected:"
, " uint8_t m_first_error;"
]
if len(opcode_accessor) > 0:
opcode_accessor = "\n".join(map(lambda s: " " + s, opcode_accessor)) + "\n"
else:
opcode_accessor = ""
if len(members) > 0:
members = "\n" + "\n".join(map(lambda s: " " + s, members)) + "\n"
else:
members = ""
if len(typedef) > 0:
typedef = "\n".join(map(lambda s: " " + s, typedef)) + "\n\n"
else:
typedef = ""
name = self.name
if self.name in _reserved_keywords: name = self.name + "_"
return \
'''
namespace error {
class %s
: public xpp::generic::error<%s,
%s>
{
public:
%s\
using xpp::generic::error<%s, %s>::error;
virtual ~%s(void) {}
%s
static std::string description(void)
{
return std::string("%s");
}
%s\
}; // class %s
}; // namespace error
''' % (self.get_name(), # class %s
self.get_name(), # : public xpp::generic::error<%s,
self.c_name, # %s>
typedef,
self.get_name(), self.c_name, # using xpp::generic::error<%s, %s>::error;
self.get_name(), # virtual ~%s(void) {}
opcode_accessor,
self.opcode_name, # static constexpr const char * opcode_literal
members,
self.get_name()) # // class %s
def set_namespace(self, namespace):
self.namespace = namespace
name = (get_namespace(namespace) + "_") if namespace.is_ext else ""
self.c_name = "xcb_%s_t" % (name + self.name.lower())
def event_dispatcher_class(namespace, cppevents):
ns = get_namespace(namespace)
ctor_name = "dispatcher"
typedef = []
ctors = []
members = []
opcode_switch = "event->response_type & ~0x80"
typedef = [ "typedef xpp::%s::extension extension;\n" % ns ]
members = \
[ "protected:"
, " Connection m_c;"
]
ctors = \
[ "template<typename C>"
, "%s(C && c)" % ctor_name
, " : m_c(std::forward<C>(c))"
, "{}"
]
# >>> if begin <<<
if namespace.is_ext:
opcode_switch = "(event->response_type & ~0x80) - m_first_event"
members += [ " uint8_t m_first_event;" ]
ctors = \
[ "template<typename C>"
, "%s(C && c, uint8_t first_event)" % (ctor_name)
, " : m_c(std::forward<C>(c))"
, " , m_first_event(first_event)"
, "{}"
, ""
, "template<typename C>"
, "%s(C && c, const xpp::%s::extension & extension)" % (ctor_name, ns)
, " : %s(std::forward<C>(c), extension->first_event)" % ctor_name
, "{}"
]
# >>> if end <<<
if len(typedef) > 0:
typedef = "\n".join(map(lambda s: " " + s, typedef)) + "\n"
else:
typedef = ""
if len(ctors) > 0:
ctors = "\n".join(map(lambda s: (" " if len(s) > 0 else "") + s, ctors)) + "\n"
else:
ctors = ""
if len(members) > 0:
members = "\n".join(map(lambda s: " " + s, members)) + "\n"
else:
members = ""
switch = event_switch_cases(cppevents, opcode_switch, "handler", "event", namespace)
return _event_dispatcher_class(typedef,
ctors,
switch,
members,
len(cppevents) > 0)
def make_class(self):
member_accessors = []
member_accessors_special = []
for field in self.fields:
if field.field_type[-1] in _resource_classes:
template_name = field.field_name.capitalize()
c_type = field.c_field_type
method_name = field.field_name.lower()
if (method_name == self.get_name()
or method_name in _reserved_keywords):
method_name += "_"
member = field.c_field_name
member_accessors.append(_field_accessor_template(c_type, method_name, member))
ns = get_namespace(self.namespace)
extension = "xpp::%s::extension" % ns
ctor = \
[ "template<typename C>"
, "%s(C && c," % self.get_name()
, (" " * len(self.get_name())) + " const std::shared_ptr<xcb_generic_event_t> & event)"
, " : base(event)"
, " , m_c(std::forward<C>(c))"
, "{}"
]
m_first_event = ""
typedef = [ "typedef xpp::%s::extension extension;" % ns ]
description = \
[ "static std::string description(void)"
, "{"
, " return std::string(\"%s\");" % self.opcode_name
, "}"
]
opcode_accessor = \
[ "static uint8_t opcode(void)"
, "{"
, " return %s;" % self.opcode_name
, "}"
]
first_event = []
if self.namespace.is_ext:
opcode_accessor += \
[ ""
, "static uint8_t opcode(uint8_t first_event)"
, "{"
, " return first_event + opcode();"
, "}"
, ""
, "static uint8_t opcode(const xpp::%s::extension & extension)" % ns
, "{"
, " return opcode(extension->first_event);"
, "}"
]
first_event = \
[ "uint8_t first_event(void)"
, "{"
, " return m_first_event;"
, "}"
]
ctor = \
[ "template<typename C>"
, "%s(C && c," % self.get_name()
, (" " * len(self.get_name())) + " uint8_t first_event,"
, (" " * len(self.get_name())) + " const std::shared_ptr<xcb_generic_event_t> & event)"
, " : base(event)"
, " , m_c(std::forward<C>(c))"
, " , m_first_event(first_event)"
, "{}"
]
m_first_event = " const uint8_t m_first_event;\n"
if len(opcode_accessor) > 0:
opcode_accessor = "\n".join(map(lambda s: " " + s, opcode_accessor)) + "\n"
else:
opcode_accessor = ""
if len(ctor) > 0:
ctor = "\n".join(map(lambda s: " " + s, ctor)) + "\n"
else:
ctor = ""
if len(typedef) > 0:
typedef = "\n".join(map(lambda s: " " + s, typedef)) + "\n\n"
else:
typedef = ""
if len(member_accessors) > 0:
member_accessors = "\n" + "\n\n".join(member_accessors) + "\n\n"
member_accessors_special = "\n" + "\n\n".join(member_accessors_special) + "\n\n"
else:
member_accessors = ""
member_accessors_special = ""
if len(description) > 0:
description = "\n" + "\n".join(map(lambda s: " " + s, description)) + "\n"
else:
description = ""
if len(first_event) > 0:
first_event = "\n" + "\n".join(map(lambda s: " " + s, first_event)) + "\n"
else:
first_event = ""
return \
'''
namespace event {
template<typename Connection>
class %s
: public xpp::generic::event<%s>
{
public:
%s\
typedef xpp::generic::event<%s> base;
%s\
virtual ~%s(void) {}
%s\
%s\
%s\
%s\
protected:
Connection m_c;
%s\
}; // class %s
%s\
}; // namespace event
''' % (self.get_name(), # class %s
self.c_name, # %s>
typedef,
self.c_name, # typedef xpp::generic::event<%s>::base;
ctor,
self.get_name(), # virtual ~%s(void) {}
opcode_accessor,
description,
first_event,
member_accessors,
m_first_event,
self.get_name(), # // class %s
member_accessors_special)
def scoped_name(self):
ns = get_namespace(self.namespace)
return "xpp::" + ns + "::error::" + self.get_name()
def make_class(self):
ns = get_namespace(self.namespace)
typedef = []
members = []
opcode_accessor = \
[ "static uint8_t opcode(void)"
, "{"
, " return %s;" % self.opcode_name
, "}"
]
if self.namespace.is_ext:
opcode_accessor += \
[ ""
, "static uint8_t opcode(uint8_t first_error)"
, "{"
, " return first_error + opcode();"
, "}"
, ""
, "static uint8_t opcode(const xpp::%s::extension & extension)" % ns
, "{"
, " return opcode(extension->first_error);"
, "}"
]
members = \
[ "protected:"
, " uint8_t m_first_error;"
]
if len(opcode_accessor) > 0:
opcode_accessor = "\n".join(map(lambda s: " " + s, opcode_accessor)) + "\n"
else:
opcode_accessor = ""
if len(members) > 0:
members = "\n" + "\n".join(map(lambda s: " " + s, members)) + "\n"
else:
members = ""
if len(typedef) > 0:
typedef = "\n".join(map(lambda s: " " + s, typedef)) + "\n\n"
else:
typedef = ""
name = self.name
if self.name in _reserved_keywords: name = self.name + "_"
return \
'''
namespace error {
class %s
: public xpp::generic::error<%s,
%s>
{
public:
%s\
using xpp::generic::error<%s, %s>::error;
virtual ~%s(void) {}
%s
static std::string description(void)
{
return std::string("%s");
}
%s\
}; // class %s
} // namespace error
''' % (self.get_name(), # class %s
self.get_name(), # : public xpp::generic::error<%s,
self.c_name, # %s>
typedef,
self.get_name(), self.c_name, # using xpp::generic::error<%s, %s>::error;
self.get_name(), # virtual ~%s(void) {}
opcode_accessor,
self.opcode_name, # static constexpr const char * opcode_literal
members,
self.get_name()) # // class %s
def event_dispatcher_class(namespace, cppevents):
ns = get_namespace(namespace)
ctor_name = "dispatcher"
typedef = []
ctors = []
members = []
opcode_switch = "event->response_type & ~0x80"
typedef = ["typedef xpp::%s::extension extension;\n" % ns]
members = \
[ "protected:"
, " Connection m_c;"
]
ctors = \
[ "template<typename C>"
, "%s(C && c)" % ctor_name
, " : m_c(std::forward<C>(c))"
, "{}"
]
# >>> if begin <<<
if namespace.is_ext:
opcode_switch = "(event->response_type & ~0x80) - m_first_event"
members += [" uint8_t m_first_event;"]
ctors = \
[ "template<typename C>"
, "%s(C && c, uint8_t first_event)" % (ctor_name)
, " : m_c(std::forward<C>(c))"
, " , m_first_event(first_event)"
, "{}"
, ""
, "template<typename C>"
, "%s(C && c, const xpp::%s::extension & extension)" % (ctor_name, ns)
, " : %s(std::forward<C>(c), extension->first_event)" % ctor_name
, "{}"
]
# >>> if end <<<
if len(typedef) > 0:
typedef = "\n".join(map(lambda s: " " + s, typedef)) + "\n"
else:
typedef = ""
if len(ctors) > 0:
ctors = "\n".join(
map(lambda s: (" " if len(s) > 0 else "") + s, ctors)) + "\n"
else:
ctors = ""
if len(members) > 0:
members = "\n".join(map(lambda s: " " + s, members)) + "\n"
else:
members = ""
switch = event_switch_cases(cppevents, opcode_switch, "handler", "event",
namespace)
return _event_dispatcher_class(typedef, ctors, switch, members,
len(cppevents) > 0)
def make_class(self):
member_accessors = []
member_accessors_special = []
for field in self.fields:
if field.field_type[-1] in _resource_classes:
template_name = field.field_name.capitalize()
c_type = field.c_field_type
method_name = field.field_name.lower()
if (method_name == self.get_name()
or method_name in _reserved_keywords):
method_name += "_"
member = field.c_field_name
member_accessors.append(
_field_accessor_template(c_type, method_name, member))
ns = get_namespace(self.namespace)
extension = "xpp::%s::extension" % ns
ctor = \
[ "template<typename C>"
, "%s(C && c," % self.get_name()
, (" " * len(self.get_name())) + " const std::shared_ptr<xcb_generic_event_t> & event)"
, " : base(event)"
, " , m_c(std::forward<C>(c))"
, "{}"
]
m_first_event = ""
typedef = ["typedef xpp::%s::extension extension;" % ns]
description = \
[ "static std::string description(void)"
, "{"
, " return std::string(\"%s\");" % self.opcode_name
, "}"
]
opcode_accessor = \
[ "static uint8_t opcode(void)"
, "{"
, " return %s;" % self.opcode_name
, "}"
]
first_event = []
if self.namespace.is_ext:
opcode_accessor += \
[ ""
, "static uint8_t opcode(uint8_t first_event)"
, "{"
, " return first_event + opcode();"
, "}"
, ""
, "static uint8_t opcode(const xpp::%s::extension & extension)" % ns
, "{"
, " return opcode(extension->first_event);"
, "}"
]
first_event = \
[ "uint8_t first_event(void)"
, "{"
, " return m_first_event;"
, "}"
]
ctor = \
[ "template<typename C>"
, "%s(C && c," % self.get_name()
, (" " * len(self.get_name())) + " uint8_t first_event,"
, (" " * len(self.get_name())) + " const std::shared_ptr<xcb_generic_event_t> & event)"
, " : base(event)"
, " , m_c(std::forward<C>(c))"
, " , m_first_event(first_event)"
, "{}"
]
m_first_event = " const uint8_t m_first_event;\n"
if len(opcode_accessor) > 0:
opcode_accessor = "\n".join(
map(lambda s: " " + s, opcode_accessor)) + "\n"
else:
opcode_accessor = ""
if len(ctor) > 0:
ctor = "\n".join(map(lambda s: " " + s, ctor)) + "\n"
else:
ctor = ""
if len(typedef) > 0:
typedef = "\n".join(map(lambda s: " " + s, typedef)) + "\n\n"
else:
typedef = ""
if len(member_accessors) > 0:
member_accessors = "\n" + "\n\n".join(member_accessors) + "\n\n"
member_accessors_special = "\n" + "\n\n".join(
member_accessors_special) + "\n\n"
else:
member_accessors = ""
member_accessors_special = ""
if len(description) > 0:
description = "\n" + "\n".join(
map(lambda s: " " + s, description)) + "\n"
else:
description = ""
if len(first_event) > 0:
first_event = "\n" + "\n".join(
map(lambda s: " " + s, first_event)) + "\n"
else:
first_event = ""
return \
'''
namespace event {
template<typename Connection>
class %s
: public xpp::generic::event<%s>
{
public:
%s\
typedef xpp::generic::event<%s> base;
%s\
virtual ~%s(void) {}
%s\
%s\
%s\
%s\
protected:
Connection m_c;
%s\
}; // class %s
%s\
}; // namespace event
''' % (self.get_name(), # class %s
self.c_name, # %s>
typedef,
self.c_name, # typedef xpp::generic::event<%s>::base;
ctor,
self.get_name(), # virtual ~%s(void) {}
opcode_accessor,
description,
first_event,
member_accessors,
m_first_event,
self.get_name(), # // class %s
member_accessors_special)
def scoped_name(self):
ns = get_namespace(self.namespace)
return "xpp::" + ns + "::event::" + self.get_name()
