eventstruct is a new xml element that allows to use events
as part of requests.
This is, e.g., needed by the SendExtensionEvent request
of the XINPUT extension.
Signed-off-by: Christian Linhart <***@demorecorder.com>
---
doc/xml-xcb.txt | 29 +++++++++++++++++++
src/xcb.xsd | 17 +++++++++++
xcbgen/matcher.py | 7 +++++
xcbgen/state.py | 41 ++++++++++++++++++++++++++
xcbgen/xtypes.py | 87 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
5 files changed, 181 insertions(+)
diff --git a/doc/xml-xcb.txt b/doc/xml-xcb.txt
index 9cef1de..f5b9aed 100644
--- a/doc/xml-xcb.txt
+++ b/doc/xml-xcb.txt
@@ -72,14 +72,20 @@ Top-Level Elements
This element represents a union of data types, which can hold one value of
any of those types. The name attribute gives the name of the union. The
content represents the fields of the union, and consists of one or more of
the field and pad elements described in the section "Structure Contents
below".
+<eventstruct name="identifier">event-type-selector list</struct>
+
+ This element represents a data structure that is the wire-representation of
+ an event. The event can be any type that's selected by the
+ event-type-selector list.
+
<xidtype name="identifier" />
This element represents an identifier for a particular type of resource.
The name attribute gives the name of the new type.
<enum name="identifier">
<item name="identifier">[optional expression]</item>
@@ -355,14 +361,37 @@ Expressions
This element represents the number of bits set in the expression.
<listelement-ref/>
This element represents the current list-element when used inside
a list-iteration expression such as <sumof>.
+
+Event-Type-Selector List
+------------------------
+
+ The event-type-selector list selects a set of eventtypes.
+ It consists of any number of the following elements:
+
+ <allowed extension="identifier" xge="boolean"
+ opcode-min="integer" opcode-max="integer" />
+
+ The extension attribute selects events from the given extension.
+
+ If the xge attribute is true, the event is an X Generic Event and
+ will be treated as such.
+
+ opcode-min and opcode-max describe the minimum and maximum opcode
+ respectively. The opcode is the same number as the number-attribute
+ of an event definition. I.e. this is the offset from the event-base
+ to the actual number used on the wire.
+
+ In the current implementation, only xge="false" is supported.
+
+
Documentation
-------------
Documentation for each request, reply or event is stored in the appropriate
element using a <doc> element. The <doc> element can contain the following
elements:
diff --git a/src/xcb.xsd b/src/xcb.xsd
index f0c5f44..dc3d7cc 100644
--- a/src/xcb.xsd
+++ b/src/xcb.xsd
@@ -236,14 +236,30 @@ authorization from the authors.
<!-- Type for a packet structure copy -->
<xsd:complexType name="packet-struct-copy">
<xsd:attribute name="name" type="xsd:string" use="required" />
<xsd:attribute name="number" type="xsd:integer" use="required" />
<xsd:attribute name="ref" type="xsd:string" use="required" />
</xsd:complexType>
+ <!-- Type for a structure that is an event
+ which can be of an event type from a set of event types -->
+ <xsd:complexType name="eventstruct">
+ <xsd:sequence>
+ <xsd:element name="allowed">
+ <xsd:complexType>
+ <xsd:attribute name="extension" type="xsd:string" use="required" />
+ <xsd:attribute name="xge" type="xsd:boolean" use="required" />
+ <xsd:attribute name="opcode-min" type="xsd:integer" use="required" />
+ <xsd:attribute name="opcode-max" type="xsd:integer" use="required" />
+ </xsd:complexType>
+ </xsd:element>
+ </xsd:sequence>
+ <xsd:attribute name="name" type="xsd:string" use="required" />
+ </xsd:complexType>
+
<!-- Type for bit values -->
<xsd:simpleType name="bitType">
<xsd:restriction base="xsd:integer">
<xsd:minInclusive value="0" />
<xsd:maxExclusive value="32" />
</xsd:restriction>
</xsd:simpleType>
@@ -350,14 +366,15 @@ authorization from the authors.
</xsd:complexType>
</xsd:element>
<xsd:element name="eventcopy" type="packet-struct-copy" />
<xsd:element name="error" type="packet-struct" />
<xsd:element name="errorcopy" type="packet-struct-copy" />
<xsd:element name="struct" type="struct" />
<xsd:element name="union" type="struct" />
+ <xsd:element name="eventstruct" type="eventstruct" />
<xsd:element name="xidtype">
<xsd:complexType>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
<xsd:element name="xidunion">
<xsd:complexType>
diff --git a/xcbgen/matcher.py b/xcbgen/matcher.py
index bfa315e..97a8b43 100644
--- a/xcbgen/matcher.py
+++ b/xcbgen/matcher.py
@@ -53,14 +53,20 @@ def enum(node, module, namespace):
def struct(node, module, namespace):
id = node.get('name')
name = namespace.prefix + (id,)
type = Struct(name, node)
module.add_type(id, namespace.ns, name, type)
+def eventstruct(node, module, namespace):
+ id = node.get('name')
+ name = namespace.prefix + (id,)
+ type = EventStruct(name, node)
+ module.add_type(id, namespace.ns, name, type)
+
def union(node, module, namespace):
id = node.get('name')
name = namespace.prefix + (id,)
type = Union(name, node)
module.add_type(id, namespace.ns, name, type)
def request(node, module, namespace):
@@ -99,14 +105,15 @@ def errorcopy(node, module, namespace):
funcs = {'import' : import_,
'typedef' : typedef,
'xidtype' : xidtype,
'xidunion' : xidunion,
'enum' : enum,
'struct' : struct,
+ 'eventstruct' : eventstruct,
'union' : union,
'request' : request,
'event' : event,
'eventcopy' : eventcopy,
'error' : error,
'errorcopy' : errorcopy}
diff --git a/xcbgen/state.py b/xcbgen/state.py
index a6ad3a1..a8346bb 100644
--- a/xcbgen/state.py
+++ b/xcbgen/state.py
@@ -28,28 +28,42 @@ class Namespace(object):
self.dir = dirname(filename)
self.file = basename(filename)
# Parse XML
self.root = parse(filename).getroot()
self.header = self.root.get('header')
self.ns = self.header + ':'
+
+ # Events
+ self.events = {}
# Get root element attributes
if self.root.get('extension-xname', False):
self.is_ext = True
self.major_version = self.root.get('major-version')
self.minor_version = self.root.get('minor-version')
self.ext_xname = self.root.get('extension-xname')
self.ext_name = self.root.get('extension-name')
self.prefix = ('xcb', self.ext_name)
else:
self.is_ext = False
self.ext_name = ''
self.prefix = ('xcb',)
+ def add_event(self, id, name, item):
+ self.events[id] = (name, item)
+
+ def get_event_by_opcode(self, opcode, is_ge_event):
+ for id, (name, event) in self.events.items():
+ if event.is_ge_event == is_ge_event:
+ opcode_specific_name = event.get_name_for_opcode( opcode )
+ if opcode_specific_name is not None:
+ return (opcode_specific_name, event)
+ return None
+
class Module(object):
'''
This is the grand, encompassing class that represents an entire XCB specification.
Only gets instantiated once, in the main() routine.
Don't need to worry about this much except to declare it and to get the namespace.
@@ -68,14 +82,19 @@ class Module(object):
self.direct_imports = []
self.import_level = 0
self.types = {}
self.events = {}
self.errors = {}
self.all = []
+ # dict of namespaces by ext_name
+ self.namespaces = {}
+ # enter the main namespace here
+ self.namespaces[self.namespace.ext_name] = self.namespace
+
# Register some common types
self.add_type('CARD8', '', ('uint8_t',), tcard8)
self.add_type('CARD16', '', ('uint16_t',), tcard16)
self.add_type('CARD32', '', ('uint32_t',), tcard32)
self.add_type('CARD64', '', ('uint64_t',), tcard64)
self.add_type('INT8', '', ('int8_t',), tint8)
self.add_type('INT16', '', ('int16_t',), tint16)
@@ -90,14 +109,15 @@ class Module(object):
# This goes out and parses the rest of the XML
def register(self):
matcher.execute(self, self.namespace)
# Recursively resolve all types
def resolve(self):
+ self.add_events_to_namespaces()
for (name, item) in self.all:
self.pads = 0
item.resolve(self)
# Call all the output methods
def generate(self):
self.open()
@@ -108,14 +128,15 @@ class Module(object):
self.close()
# Keeps track of what's been imported so far.
def add_import(self, name, namespace):
if self.import_level == 0:
self.direct_imports.append((name, namespace.header))
self.imports.append((name, namespace.header))
+ self.namespaces[namespace.ext_name] = namespace
def has_import(self, name):
for (name_, header) in self.imports:
if name_ == name:
return True
return False
@@ -145,25 +166,45 @@ class Module(object):
def get_type(self, id):
return self.get_type_impl(id, 1)
def get_type_name(self, id):
return self.get_type_impl(id, 0)
+ def get_namespace(self, ext_name):
+ return self.namespaces[ext_name]
+
# Keeps track of request datatypes
def add_request(self, id, name, item):
if name[:-1] == self.namespace.prefix:
self.all.append((name, item))
# Keeps track of event datatypes
def add_event(self, id, name, item):
self.events[id] = (name, item)
if name[:-1] == self.namespace.prefix:
self.all.append((name, item))
+
+ def add_events_to_namespaces(self):
+ # add to its namespace object
+ for id, (name,item) in self.events.items():
+ if name[:-1] == ('xcb',):
+ # core event
+ namespace_name = ''
+ else:
+ # extension event
+ namespace_name = name[-2]
+
+ namespace = self.namespaces[namespace_name]
+
+ if namespace is not None:
+ namespace.add_event(id, name, item)
+
+
def get_event(self, id):
return self.events[id][1]
# Keeps track of error datatypes
def add_error(self, id, name, item):
self.errors[id] = (name, item)
if name[:-1] == self.namespace.prefix:
diff --git a/xcbgen/xtypes.py b/xcbgen/xtypes.py
index b83b119..c1f5986 100644
--- a/xcbgen/xtypes.py
+++ b/xcbgen/xtypes.py
@@ -32,14 +32,16 @@ class Type(object):
self.is_simple = False
self.is_list = False
self.is_expr = False
self.is_container = False
self.is_reply = False
self.is_union = False
self.is_pad = False
+ self.is_eventstruct = False
+ self.is_event = False
self.is_switch = False
self.is_case_or_bitcase = False
self.is_bitcase = False
self.is_case = False
self.required_start_align = Alignment()
# the biggest align value of an align-pad contained in this type
@@ -1160,14 +1162,90 @@ class Request(ComplexType):
if self.reply:
self.reply.resolve(module)
out = __main__.output['request']
+class EventStructAllowedRule:
+
+ def __init__(self, parent, elt):
+ self.elt = elt
+ self.extension = elt.get('extension')
+ self.ge_events = elt.get('xge') == "true"
+ self.min_opcode = int( elt.get('opcode-min') )
+ self.max_opcode = int( elt.get('opcode-max') )
+
+ def resolve(self, parent, module):
+ # get the namespace of the specified extension
+ extension_namespace = module.get_namespace( self.extension )
+ if extension_namespace is None:
+ raise Exception( "EventStructAllowedRule.resolve: cannot find extension \"" + self.extension + "\"" )
+ return
+
+ # find and add the selected events
+ for opcode in range(self.min_opcode, self.max_opcode):
+ name_and_event = extension_namespace.get_event_by_opcode( opcode, self.ge_events )
+ if name_and_event is None:
+ # could not find event -> error handling
+ if self.ge_events:
+ raise Exception("EventStructAllowedRule.resolve: cannot find xge-event with opcode " + str(opcode) + " in extension " + self.extension )
+ else:
+ raise Exception("EventStructAllowedRule.resolve: cannot find oldstyle-event with opcode " + str(opcode) + " in extension " + self.extension )
+ return
+
+ ( name, event ) = name_and_event
+ # add event to EventStruct
+ parent.add_event( module, self.extension, opcode, name, event )
+
+
+class EventStruct(Union):
+ '''
+ Derived class representing an event-use-as-struct data type.
+ '''
+
+ def __init__(self, name, elt):
+ Union.__init__(self, name, elt)
+ self.is_eventstruct = True
+ self.events = []
+ self.allowedRules = []
+ self.contains_ge_events = False
+ for item in list(elt):
+ if item.tag == 'allowed':
+ allowedRule = EventStructAllowedRule(self, item)
+ self.allowedRules.append( allowedRule )
+ if allowedRule.ge_events:
+ self.contains_ge_events = True
+
+ out = __main__.output['eventstruct']
+
+ def resolve(self, module):
+ if self.resolved:
+ return
+ for allowedRule in self.allowedRules:
+ allowedRule.resolve(self, module)
+ Union.resolve(self,module)
+ self.resolved = True
+
+ # add event. called by resolve
+ def add_event(self, module, extension, opcode, name, event_type ):
+ self.events.append( (extension, opcode, name, event_type) )
+ # Add the field to ourself
+ event_type.make_member_of(module, self, name, name[-1], True, True, False)
+ # Recursively resolve the event (could be another structure, list)
+ event_type.resolve(module)
+
+ def fixed_size(self):
+ is_fixed_size = True
+ for extension, opcode, name, event in self.events:
+ if not event.fixed_size():
+ is_fixed_size = False
+ return is_fixed_size
+
+
class Event(ComplexType):
'''
Derived class representing an event data type.
Public fields added:
opcodes is a dictionary of name -> opcode number, for eventcopies.
'''
@@ -1179,24 +1257,33 @@ class Event(ComplexType):
self.opcodes = {}
self.has_seq = not bool(elt.get('no-sequence-number'))
self.is_ge_event = bool(elt.get('xge'))
+ self.is_event = True
+
self.doc = None
for item in list(elt):
if item.tag == 'doc':
self.doc = Doc(name, item)
def add_opcode(self, opcode, name, main):
self.opcodes[name] = opcode
if main:
self.name = name
+ def get_name_for_opcode(self, opcode):
+ for name, my_opcode in self.opcodes.items():
+ if int(my_opcode) == opcode:
+ return name
+ else:
+ return None
+
def resolve(self, module):
def add_event_header():
self.fields.append(Field(tcard8, tcard8.name, 'response_type', False, True, True))
if self.has_seq:
self.fields.append(_placeholder_byte)
self.fields.append(Field(tcard16, tcard16.name, 'sequence', False, True, True))
--
2.1.4