From dafebc5bb70303f0b5baf0b087cf4d9a64b5c7f0 Mon Sep 17 00:00:00 2001 From: marha Date: Mon, 12 Sep 2011 11:27:51 +0200 Subject: Synchronised line endinge with release branch --- libxcb/xcb-proto/src/sync.xml | 458 ++++++------- libxcb/xcb-proto/xcbgen/matcher.py | 226 +++---- libxcb/xcb-proto/xcbgen/state.py | 332 +++++----- libxcb/xcb-proto/xcbgen/xtypes.py | 1264 ++++++++++++++++++------------------ 4 files changed, 1140 insertions(+), 1140 deletions(-) (limited to 'libxcb/xcb-proto') diff --git a/libxcb/xcb-proto/src/sync.xml b/libxcb/xcb-proto/src/sync.xml index f690cca04..516d149ab 100644 --- a/libxcb/xcb-proto/src/sync.xml +++ b/libxcb/xcb-proto/src/sync.xml @@ -1,229 +1,229 @@ - - - - xproto - - - - - - - - - - - - - - - - - - - - - - - - - - - 0 - 1 - 2 - 3 - 4 - 5 - - - - - - - - - - - - - name_len - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - counters_len - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + xproto + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + 1 + 2 + 3 + 4 + 5 + + + + + + + + + + + + + name_len + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + counters_len + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/libxcb/xcb-proto/xcbgen/matcher.py b/libxcb/xcb-proto/xcbgen/matcher.py index c4d99fc57..6e45b236c 100644 --- a/libxcb/xcb-proto/xcbgen/matcher.py +++ b/libxcb/xcb-proto/xcbgen/matcher.py @@ -1,113 +1,113 @@ -''' -XML parser. One function for each top-level element in the schema. - -Most functions just declare a new object and add it to the module. -For typedefs, eventcopies, xidtypes, and other aliases though, -we do not create a new type object, we just record the existing one under a new name. -''' - -from os.path import join -from xml.etree.cElementTree import parse - -from xcbgen.xtypes import * - -def import_(node, module, namespace): - ''' - For imports, we load the file, create a new namespace object, - execute recursively, then record the import (for header files, etc.) - ''' - # To avoid circular import error - from xcbgen import state - new_file = join(namespace.dir, '%s.xml' % node.text) - new_root = parse(new_file).getroot() - new_namespace = state.Namespace(new_file) - execute(module, new_namespace) - if not module.has_import(node.text): - module.add_import(node.text, new_namespace) - -def typedef(node, module, namespace): - id = node.get('newname') - name = namespace.prefix + (id,) - type = module.get_type(node.get('oldname')) - module.add_type(id, namespace.ns, name, type) - -def xidtype(node, module, namespace): - id = node.get('name') - name = namespace.prefix + (id,) - type = module.get_type('CARD32') - module.add_type(id, namespace.ns, name, type) - -def xidunion(node, module, namespace): - id = node.get('name') - name = namespace.prefix + (id,) - type = module.get_type('CARD32') - module.add_type(id, namespace.ns, name, type) - -def enum(node, module, namespace): - id = node.get('name') - name = namespace.prefix + (id,) - type = Enum(name, node) - module.add_type(id, namespace.ns, name, type) - -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 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): - id = node.get('name') - name = namespace.prefix + (id,) - type = Request(name, node) - module.add_request(id, name, type) - -def event(node, module, namespace): - id = node.get('name') - name = namespace.prefix + (id,) - event = Event(name, node) - event.add_opcode(node.get('number'), name, True) - module.add_event(id, name, event) - -def eventcopy(node, module, namespace): - id = node.get('name') - name = namespace.prefix + (id,) - event = module.get_event(node.get('ref')) - event.add_opcode(node.get('number'), name, False) - module.add_event(id, name, event) - -def error(node, module, namespace): - id = node.get('name') - name = namespace.prefix + (id,) - error = Error(name, node) - error.add_opcode(node.get('number'), name, True) - module.add_error(id, name, error) - -def errorcopy(node, module, namespace): - id = node.get('name') - name = namespace.prefix + (id,) - error = module.get_error(node.get('ref')) - error.add_opcode(node.get('number'), name, False) - module.add_error(id, name, error) - -funcs = {'import' : import_, - 'typedef' : typedef, - 'xidtype' : xidtype, - 'xidunion' : xidunion, - 'enum' : enum, - 'struct' : struct, - 'union' : union, - 'request' : request, - 'event' : event, - 'eventcopy' : eventcopy, - 'error' : error, - 'errorcopy' : errorcopy} - -def execute(module, namespace): - for elt in list(namespace.root): - funcs[elt.tag](elt, module, namespace) +''' +XML parser. One function for each top-level element in the schema. + +Most functions just declare a new object and add it to the module. +For typedefs, eventcopies, xidtypes, and other aliases though, +we do not create a new type object, we just record the existing one under a new name. +''' + +from os.path import join +from xml.etree.cElementTree import parse + +from xcbgen.xtypes import * + +def import_(node, module, namespace): + ''' + For imports, we load the file, create a new namespace object, + execute recursively, then record the import (for header files, etc.) + ''' + # To avoid circular import error + from xcbgen import state + new_file = join(namespace.dir, '%s.xml' % node.text) + new_root = parse(new_file).getroot() + new_namespace = state.Namespace(new_file) + execute(module, new_namespace) + if not module.has_import(node.text): + module.add_import(node.text, new_namespace) + +def typedef(node, module, namespace): + id = node.get('newname') + name = namespace.prefix + (id,) + type = module.get_type(node.get('oldname')) + module.add_type(id, namespace.ns, name, type) + +def xidtype(node, module, namespace): + id = node.get('name') + name = namespace.prefix + (id,) + type = module.get_type('CARD32') + module.add_type(id, namespace.ns, name, type) + +def xidunion(node, module, namespace): + id = node.get('name') + name = namespace.prefix + (id,) + type = module.get_type('CARD32') + module.add_type(id, namespace.ns, name, type) + +def enum(node, module, namespace): + id = node.get('name') + name = namespace.prefix + (id,) + type = Enum(name, node) + module.add_type(id, namespace.ns, name, type) + +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 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): + id = node.get('name') + name = namespace.prefix + (id,) + type = Request(name, node) + module.add_request(id, name, type) + +def event(node, module, namespace): + id = node.get('name') + name = namespace.prefix + (id,) + event = Event(name, node) + event.add_opcode(node.get('number'), name, True) + module.add_event(id, name, event) + +def eventcopy(node, module, namespace): + id = node.get('name') + name = namespace.prefix + (id,) + event = module.get_event(node.get('ref')) + event.add_opcode(node.get('number'), name, False) + module.add_event(id, name, event) + +def error(node, module, namespace): + id = node.get('name') + name = namespace.prefix + (id,) + error = Error(name, node) + error.add_opcode(node.get('number'), name, True) + module.add_error(id, name, error) + +def errorcopy(node, module, namespace): + id = node.get('name') + name = namespace.prefix + (id,) + error = module.get_error(node.get('ref')) + error.add_opcode(node.get('number'), name, False) + module.add_error(id, name, error) + +funcs = {'import' : import_, + 'typedef' : typedef, + 'xidtype' : xidtype, + 'xidunion' : xidunion, + 'enum' : enum, + 'struct' : struct, + 'union' : union, + 'request' : request, + 'event' : event, + 'eventcopy' : eventcopy, + 'error' : error, + 'errorcopy' : errorcopy} + +def execute(module, namespace): + for elt in list(namespace.root): + funcs[elt.tag](elt, module, namespace) diff --git a/libxcb/xcb-proto/xcbgen/state.py b/libxcb/xcb-proto/xcbgen/state.py index 902a86341..ae3d2d45f 100644 --- a/libxcb/xcb-proto/xcbgen/state.py +++ b/libxcb/xcb-proto/xcbgen/state.py @@ -1,166 +1,166 @@ -''' -This module contains the namespace class and the singleton module class. -''' -from os.path import dirname, basename -from xml.etree.cElementTree import parse - -from xcbgen import matcher -from xcbgen.error import * -from xcbgen.xtypes import * - -import __main__ - -class Namespace(object): - ''' - Contains the naming information for an extension. - - Public fields: - - header is the header attribute ("header file" name). - is_ext is true for extensions, false for xproto. - major_version and minor_version are extension version info. - ext_xname is the X extension name string. - ext_name is the XCB extension name prefix. - ''' - def __init__(self, filename): - # Path info - self.path = filename - 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 + ':' - - # 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',) - - -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. - - Public fields: - namespace contains the namespace info for the spec. - ''' - open = __main__.output['open'] - close = __main__.output['close'] - - def __init__(self, filename, output): - self.namespace = Namespace(filename) - self.output = output - - self.imports = [] - self.types = {} - self.events = {} - self.errors = {} - self.all = [] - - # 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('INT8', '', ('int8_t',), tint8) - self.add_type('INT16', '', ('int16_t',), tint16) - self.add_type('INT32', '', ('int32_t',), tint32) - self.add_type('BYTE', '', ('uint8_t',), tcard8) - self.add_type('BOOL', '', ('uint8_t',), tcard8) - self.add_type('char', '', ('char',), tchar) - self.add_type('float', '', ('float',), tfloat) - self.add_type('double', '', ('double',), tdouble) - self.add_type('void', '', ('void',), tcard8) - - # 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): - for (name, item) in self.all: - item.resolve(self) - - # Call all the output methods - def generate(self): - self.open() - - for (name, item) in self.all: - item.out(name) - - self.close() - - # Keeps track of what's been imported so far. - def add_import(self, name, namespace): - self.imports.append((name, namespace.header)) - - def has_import(self, name): - for (name_, header) in self.imports: - if name_ == name: - return True - return False - - # Keeps track of non-request/event/error datatypes - def add_type(self, id, ns, name, item): - key = ns + id - if key in self.types: - return - self.types[key] = (name, item) - if name[:-1] == self.namespace.prefix: - self.all.append((name, item)) - - def get_type_impl(self, id, idx): - key = id - if key in self.types: - return self.types[key][idx] - - key = self.namespace.ns + id - if key in self.types: - return self.types[key][idx] - - for key in self.types.keys(): - if key.rpartition(':')[2] == id: - return self.types[key][idx] - - raise ResolveException('Type %s not found' % id) - - 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) - - # 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 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: - self.all.append((name, item)) - - def get_error(self, id): - return self.errors[id][1] +''' +This module contains the namespace class and the singleton module class. +''' +from os.path import dirname, basename +from xml.etree.cElementTree import parse + +from xcbgen import matcher +from xcbgen.error import * +from xcbgen.xtypes import * + +import __main__ + +class Namespace(object): + ''' + Contains the naming information for an extension. + + Public fields: + + header is the header attribute ("header file" name). + is_ext is true for extensions, false for xproto. + major_version and minor_version are extension version info. + ext_xname is the X extension name string. + ext_name is the XCB extension name prefix. + ''' + def __init__(self, filename): + # Path info + self.path = filename + 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 + ':' + + # 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',) + + +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. + + Public fields: + namespace contains the namespace info for the spec. + ''' + open = __main__.output['open'] + close = __main__.output['close'] + + def __init__(self, filename, output): + self.namespace = Namespace(filename) + self.output = output + + self.imports = [] + self.types = {} + self.events = {} + self.errors = {} + self.all = [] + + # 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('INT8', '', ('int8_t',), tint8) + self.add_type('INT16', '', ('int16_t',), tint16) + self.add_type('INT32', '', ('int32_t',), tint32) + self.add_type('BYTE', '', ('uint8_t',), tcard8) + self.add_type('BOOL', '', ('uint8_t',), tcard8) + self.add_type('char', '', ('char',), tchar) + self.add_type('float', '', ('float',), tfloat) + self.add_type('double', '', ('double',), tdouble) + self.add_type('void', '', ('void',), tcard8) + + # 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): + for (name, item) in self.all: + item.resolve(self) + + # Call all the output methods + def generate(self): + self.open() + + for (name, item) in self.all: + item.out(name) + + self.close() + + # Keeps track of what's been imported so far. + def add_import(self, name, namespace): + self.imports.append((name, namespace.header)) + + def has_import(self, name): + for (name_, header) in self.imports: + if name_ == name: + return True + return False + + # Keeps track of non-request/event/error datatypes + def add_type(self, id, ns, name, item): + key = ns + id + if key in self.types: + return + self.types[key] = (name, item) + if name[:-1] == self.namespace.prefix: + self.all.append((name, item)) + + def get_type_impl(self, id, idx): + key = id + if key in self.types: + return self.types[key][idx] + + key = self.namespace.ns + id + if key in self.types: + return self.types[key][idx] + + for key in self.types.keys(): + if key.rpartition(':')[2] == id: + return self.types[key][idx] + + raise ResolveException('Type %s not found' % id) + + 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) + + # 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 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: + self.all.append((name, item)) + + def get_error(self, id): + return self.errors[id][1] diff --git a/libxcb/xcb-proto/xcbgen/xtypes.py b/libxcb/xcb-proto/xcbgen/xtypes.py index 882acc9b8..14c318ac3 100644 --- a/libxcb/xcb-proto/xcbgen/xtypes.py +++ b/libxcb/xcb-proto/xcbgen/xtypes.py @@ -1,632 +1,632 @@ -''' -This module contains the classes which represent XCB data types. -''' -from xcbgen.expr import Field, Expression -import __main__ - -class Type(object): - ''' - Abstract base class for all XCB data types. - Contains default fields, and some abstract methods. - ''' - def __init__(self, name): - ''' - Default structure initializer. Sets up default fields. - - Public fields: - name is a tuple of strings specifying the full type name. - size is the size of the datatype in bytes, or None if variable-sized. - nmemb is 1 for non-list types, None for variable-sized lists, otherwise number of elts. - booleans for identifying subclasses, because I can't figure out isinstance(). - ''' - self.name = name - self.size = None - self.nmemb = None - self.resolved = False - - # Screw isinstance(). - 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_switch = False - self.is_bitcase = False - - def resolve(self, module): - ''' - Abstract method for resolving a type. - This should make sure any referenced types are already declared. - ''' - raise Exception('abstract resolve method not overridden!') - - def out(self, name): - ''' - Abstract method for outputting code. - These are declared in the language-specific modules, and - there must be a dictionary containing them declared when this module is imported! - ''' - raise Exception('abstract out method not overridden!') - - def fixed_size(self): - ''' - Abstract method for determining if the data type is fixed-size. - ''' - raise Exception('abstract fixed_size method not overridden!') - - def make_member_of(self, module, complex_type, field_type, field_name, visible, wire, auto): - ''' - Default method for making a data type a member of a structure. - Extend this if the data type needs to add an additional length field or something. - - module is the global module object. - complex_type is the structure object. - see Field for the meaning of the other parameters. - ''' - new_field = Field(self, field_type, field_name, visible, wire, auto) - - # We dump the _placeholder_byte if any fields are added. - for (idx, field) in enumerate(complex_type.fields): - if field == _placeholder_byte: - complex_type.fields[idx] = new_field - return - - complex_type.fields.append(new_field) - - -class SimpleType(Type): - ''' - Derived class which represents a cardinal type like CARD32 or char. - Any type which is typedef'ed to cardinal will be one of these. - - Public fields added: - none - ''' - def __init__(self, name, size): - Type.__init__(self, name) - self.is_simple = True - self.size = size - self.nmemb = 1 - - def resolve(self, module): - self.resolved = True - - def fixed_size(self): - return True - - out = __main__.output['simple'] - - -# Cardinal datatype globals. See module __init__ method. -tcard8 = SimpleType(('uint8_t',), 1) -tcard16 = SimpleType(('uint16_t',), 2) -tcard32 = SimpleType(('uint32_t',), 4) -tint8 = SimpleType(('int8_t',), 1) -tint16 = SimpleType(('int16_t',), 2) -tint32 = SimpleType(('int32_t',), 4) -tchar = SimpleType(('char',), 1) -tfloat = SimpleType(('float',), 4) -tdouble = SimpleType(('double',), 8) - - -class Enum(SimpleType): - ''' - Derived class which represents an enum. Fixed-size. - - Public fields added: - values contains a list of (name, value) tuples. value is empty, or a number. - bits contains a list of (name, bitnum) tuples. items only appear if specified as a bit. bitnum is a number. - ''' - def __init__(self, name, elt): - SimpleType.__init__(self, name, 4) - self.values = [] - self.bits = [] - for item in list(elt): - # First check if we're using a default value - if len(list(item)) == 0: - self.values.append((item.get('name'), '')) - continue - - # An explicit value or bit was specified. - value = list(item)[0] - if value.tag == 'value': - self.values.append((item.get('name'), value.text)) - elif value.tag == 'bit': - self.values.append((item.get('name'), '%u' % (1 << int(value.text, 0)))) - self.bits.append((item.get('name'), value.text)) - - def resolve(self, module): - self.resolved = True - - def fixed_size(self): - return True - - out = __main__.output['enum'] - - -class ListType(Type): - ''' - Derived class which represents a list of some other datatype. Fixed- or variable-sized. - - Public fields added: - member is the datatype of the list elements. - parent is the structure type containing the list. - expr is an Expression object containing the length information, for variable-sized lists. - ''' - def __init__(self, elt, member, *parent): - Type.__init__(self, member.name) - self.is_list = True - self.member = member - self.parents = list(parent) - - if elt.tag == 'list': - elts = list(elt) - self.expr = Expression(elts[0] if len(elts) else elt, self) - elif elt.tag == 'valueparam': - self.expr = Expression(elt, self) - - self.size = member.size if member.fixed_size() else None - self.nmemb = self.expr.nmemb if self.expr.fixed_size() else None - - def make_member_of(self, module, complex_type, field_type, field_name, visible, wire, auto): - if not self.fixed_size(): - # We need a length field. - # Ask our Expression object for it's name, type, and whether it's on the wire. - lenfid = self.expr.lenfield_type - lenfield_name = self.expr.lenfield_name - lenwire = self.expr.lenwire - needlen = True - - # See if the length field is already in the structure. - for parent in self.parents: - for field in parent.fields: - if field.field_name == lenfield_name: - needlen = False - - # It isn't, so we need to add it to the structure ourself. - if needlen: - type = module.get_type(lenfid) - lenfield_type = module.get_type_name(lenfid) - type.make_member_of(module, complex_type, lenfield_type, lenfield_name, True, lenwire, False) - - # Add ourself to the structure by calling our original method. - Type.make_member_of(self, module, complex_type, field_type, field_name, visible, wire, auto) - - def resolve(self, module): - if self.resolved: - return - self.member.resolve(module) - self.expr.resolve(module, self.parents) - - # Find my length field again. We need the actual Field object in the expr. - # This is needed because we might have added it ourself above. - if not self.fixed_size(): - for parent in self.parents: - for field in parent.fields: - if field.field_name == self.expr.lenfield_name and field.wire: - self.expr.lenfield = field - break - - self.resolved = True - - def fixed_size(self): - return self.member.fixed_size() and self.expr.fixed_size() - -class ExprType(Type): - ''' - Derived class which represents an exprfield. Fixed size. - - Public fields added: - expr is an Expression object containing the value of the field. - ''' - def __init__(self, elt, member, *parent): - Type.__init__(self, member.name) - self.is_expr = True - self.member = member - self.parent = parent - - self.expr = Expression(list(elt)[0], self) - - self.size = member.size - self.nmemb = 1 - - def resolve(self, module): - if self.resolved: - return - self.member.resolve(module) - self.resolved = True - - def fixed_size(self): - return True - -class PadType(Type): - ''' - Derived class which represents a padding field. - ''' - def __init__(self, elt): - Type.__init__(self, tcard8.name) - self.is_pad = True - self.size = 1 - self.nmemb = 1 if (elt == None) else int(elt.get('bytes'), 0) - - def resolve(self, module): - self.resolved = True - - def fixed_size(self): - return True - - -class ComplexType(Type): - ''' - Derived class which represents a structure. Base type for all structure types. - - Public fields added: - fields is an array of Field objects describing the structure fields. - ''' - def __init__(self, name, elt): - Type.__init__(self, name) - self.is_container = True - self.elt = elt - self.fields = [] - self.nmemb = 1 - self.size = 0 - self.lenfield_parent = [self] - - def resolve(self, module): - if self.resolved: - return - pads = 0 - - # Resolve all of our field datatypes. - for child in list(self.elt): - if child.tag == 'pad': - field_name = 'pad' + str(pads) - fkey = 'CARD8' - type = PadType(child) - pads = pads + 1 - visible = False - elif child.tag == 'field': - field_name = child.get('name') - fkey = child.get('type') - type = module.get_type(fkey) - visible = True - elif child.tag == 'exprfield': - field_name = child.get('name') - fkey = child.get('type') - type = ExprType(child, module.get_type(fkey), *self.lenfield_parent) - visible = False - elif child.tag == 'list': - field_name = child.get('name') - fkey = child.get('type') - type = ListType(child, module.get_type(fkey), *self.lenfield_parent) - visible = True - elif child.tag == 'valueparam': - field_name = child.get('value-list-name') - fkey = 'CARD32' - type = ListType(child, module.get_type(fkey), *self.lenfield_parent) - visible = True - elif child.tag == 'switch': - field_name = child.get('name') - # construct the switch type name from the parent type and the field name - field_type = self.name + (field_name,) - type = SwitchType(field_type, child, *self.lenfield_parent) - visible = True - type.make_member_of(module, self, field_type, field_name, visible, True, False) - type.resolve(module) - continue - else: - # Hit this on Reply - continue - - # Get the full type name for the field - field_type = module.get_type_name(fkey) - # Add the field to ourself - type.make_member_of(module, self, field_type, field_name, visible, True, False) - # Recursively resolve the type (could be another structure, list) - type.resolve(module) - - self.calc_size() # Figure out how big we are - self.resolved = True - - def calc_size(self): - self.size = 0 - for m in self.fields: - if not m.wire: - continue - if m.type.fixed_size(): - self.size = self.size + (m.type.size * m.type.nmemb) - else: - self.size = None - break - - def fixed_size(self): - for m in self.fields: - if not m.type.fixed_size(): - return False - return True - -class SwitchType(ComplexType): - ''' - Derived class which represents a List of Items. - - Public fields added: - bitcases is an array of Bitcase objects describing the list items - ''' - - def __init__(self, name, elt, *parents): - ComplexType.__init__(self, name, elt) - self.parents = parents - # FIXME: switch cannot store lenfields, so it should just delegate the parents - self.lenfield_parent = list(parents) + [self] - # self.fields contains all possible fields collected from the Bitcase objects, - # whereas self.items contains the Bitcase objects themselves - self.bitcases = [] - - self.is_switch = True - elts = list(elt) - self.expr = Expression(elts[0] if len(elts) else elt, self) - - def resolve(self, module): - if self.resolved: - return -# pads = 0 - - parents = list(self.parents) + [self] - - # Resolve all of our field datatypes. - for index, child in enumerate(list(self.elt)): - if child.tag == 'bitcase': - field_name = child.get('name') - if field_name is None: - field_type = self.name + ('bitcase%d' % index,) - else: - field_type = self.name + (field_name,) - - # use self.parent to indicate anchestor, - # as switch does not contain named fields itself - type = BitcaseType(index, field_type, child, *parents) - # construct the switch type name from the parent type and the field name - if field_name is None: - type.has_name = False - # Get the full type name for the field - field_type = type.name - visible = True - - # add the field to ourself - type.make_member_of(module, self, field_type, field_name, visible, True, False) - - # recursively resolve the type (could be another structure, list) - type.resolve(module) - inserted = False - for new_field in type.fields: - # We dump the _placeholder_byte if any fields are added. - for (idx, field) in enumerate(self.fields): - if field == _placeholder_byte: - self.fields[idx] = new_field - inserted = True - break - if False == inserted: - self.fields.append(new_field) - - self.calc_size() # Figure out how big we are - self.resolved = True - - def make_member_of(self, module, complex_type, field_type, field_name, visible, wire, auto): - if not self.fixed_size(): - # We need a length field. - # Ask our Expression object for it's name, type, and whether it's on the wire. - lenfid = self.expr.lenfield_type - lenfield_name = self.expr.lenfield_name - lenwire = self.expr.lenwire - needlen = True - - # See if the length field is already in the structure. - for parent in self.parents: - for field in parent.fields: - if field.field_name == lenfield_name: - needlen = False - - # It isn't, so we need to add it to the structure ourself. - if needlen: - type = module.get_type(lenfid) - lenfield_type = module.get_type_name(lenfid) - type.make_member_of(module, complex_type, lenfield_type, lenfield_name, True, lenwire, False) - - # Add ourself to the structure by calling our original method. - Type.make_member_of(self, module, complex_type, field_type, field_name, visible, wire, auto) - - # size for switch can only be calculated at runtime - def calc_size(self): - pass - - # note: switch is _always_ of variable size, but we indicate here wether - # it contains elements that are variable-sized themselves - def fixed_size(self): - return False -# for m in self.fields: -# if not m.type.fixed_size(): -# return False -# return True - - -class Struct(ComplexType): - ''' - Derived class representing a struct data type. - ''' - out = __main__.output['struct'] - - -class Union(ComplexType): - ''' - Derived class representing a union data type. - ''' - def __init__(self, name, elt): - ComplexType.__init__(self, name, elt) - self.is_union = True - - out = __main__.output['union'] - - -class BitcaseType(ComplexType): - ''' - Derived class representing a struct data type. - ''' - def __init__(self, index, name, elt, *parent): - elts = list(elt) - self.expr = Expression(elts[0] if len(elts) else elt, self) - ComplexType.__init__(self, name, elts[1:]) - self.has_name = True - self.index = 1 - self.lenfield_parent = list(parent) + [self] - self.parents = list(parent) - self.is_bitcase = True - - def make_member_of(self, module, switch_type, field_type, field_name, visible, wire, auto): - ''' - register BitcaseType with the corresponding SwitchType - - module is the global module object. - complex_type is the structure object. - see Field for the meaning of the other parameters. - ''' - new_field = Field(self, field_type, field_name, visible, wire, auto) - - # We dump the _placeholder_byte if any bitcases are added. - for (idx, field) in enumerate(switch_type.bitcases): - if field == _placeholder_byte: - switch_type.bitcases[idx] = new_field - return - - switch_type.bitcases.append(new_field) - - def resolve(self, module): - if self.resolved: - return - - self.expr.resolve(module, self.parents+[self]) - - # Resolve the bitcase expression - ComplexType.resolve(self, module) - - -class Reply(ComplexType): - ''' - Derived class representing a reply. Only found as a field of Request. - ''' - def __init__(self, name, elt): - ComplexType.__init__(self, name, elt) - self.is_reply = True - - def resolve(self, module): - if self.resolved: - return - # Add the automatic protocol fields - self.fields.append(Field(tcard8, tcard8.name, 'response_type', False, True, True)) - self.fields.append(_placeholder_byte) - self.fields.append(Field(tcard16, tcard16.name, 'sequence', False, True, True)) - self.fields.append(Field(tcard32, tcard32.name, 'length', False, True, True)) - ComplexType.resolve(self, module) - - -class Request(ComplexType): - ''' - Derived class representing a request. - - Public fields added: - reply contains the reply datatype or None for void requests. - opcode contains the request number. - ''' - def __init__(self, name, elt): - ComplexType.__init__(self, name, elt) - self.reply = None - self.opcode = elt.get('opcode') - - for child in list(elt): - if child.tag == 'reply': - self.reply = Reply(name, child) - - def resolve(self, module): - if self.resolved: - return - # Add the automatic protocol fields - if module.namespace.is_ext: - self.fields.append(Field(tcard8, tcard8.name, 'major_opcode', False, True, True)) - self.fields.append(Field(tcard8, tcard8.name, 'minor_opcode', False, True, True)) - self.fields.append(Field(tcard16, tcard16.name, 'length', False, True, True)) - ComplexType.resolve(self, module) - else: - self.fields.append(Field(tcard8, tcard8.name, 'major_opcode', False, True, True)) - self.fields.append(_placeholder_byte) - self.fields.append(Field(tcard16, tcard16.name, 'length', False, True, True)) - ComplexType.resolve(self, module) - - if self.reply: - self.reply.resolve(module) - - out = __main__.output['request'] - - -class Event(ComplexType): - ''' - Derived class representing an event data type. - - Public fields added: - opcodes is a dictionary of name -> opcode number, for eventcopies. - ''' - def __init__(self, name, elt): - ComplexType.__init__(self, name, elt) - self.opcodes = {} - - tmp = elt.get('no-sequence-number') - self.has_seq = (tmp == None or tmp.lower() == 'false' or tmp == '0') - - def add_opcode(self, opcode, name, main): - self.opcodes[name] = opcode - if main: - self.name = name - - def resolve(self, module): - if self.resolved: - return - - # Add the automatic protocol fields - 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)) - ComplexType.resolve(self, module) - - out = __main__.output['event'] - - -class Error(ComplexType): - ''' - Derived class representing an error data type. - - Public fields added: - opcodes is a dictionary of name -> opcode number, for errorcopies. - ''' - def __init__(self, name, elt): - ComplexType.__init__(self, name, elt) - self.opcodes = {} - - def add_opcode(self, opcode, name, main): - self.opcodes[name] = opcode - if main: - self.name = name - - def resolve(self, module): - if self.resolved: - return - - # Add the automatic protocol fields - self.fields.append(Field(tcard8, tcard8.name, 'response_type', False, True, True)) - self.fields.append(Field(tcard8, tcard8.name, 'error_code', False, True, True)) - self.fields.append(Field(tcard16, tcard16.name, 'sequence', False, True, True)) - ComplexType.resolve(self, module) - - out = __main__.output['error'] - -_placeholder_byte = Field(PadType(None), tcard8.name, 'pad0', False, True, False) +''' +This module contains the classes which represent XCB data types. +''' +from xcbgen.expr import Field, Expression +import __main__ + +class Type(object): + ''' + Abstract base class for all XCB data types. + Contains default fields, and some abstract methods. + ''' + def __init__(self, name): + ''' + Default structure initializer. Sets up default fields. + + Public fields: + name is a tuple of strings specifying the full type name. + size is the size of the datatype in bytes, or None if variable-sized. + nmemb is 1 for non-list types, None for variable-sized lists, otherwise number of elts. + booleans for identifying subclasses, because I can't figure out isinstance(). + ''' + self.name = name + self.size = None + self.nmemb = None + self.resolved = False + + # Screw isinstance(). + 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_switch = False + self.is_bitcase = False + + def resolve(self, module): + ''' + Abstract method for resolving a type. + This should make sure any referenced types are already declared. + ''' + raise Exception('abstract resolve method not overridden!') + + def out(self, name): + ''' + Abstract method for outputting code. + These are declared in the language-specific modules, and + there must be a dictionary containing them declared when this module is imported! + ''' + raise Exception('abstract out method not overridden!') + + def fixed_size(self): + ''' + Abstract method for determining if the data type is fixed-size. + ''' + raise Exception('abstract fixed_size method not overridden!') + + def make_member_of(self, module, complex_type, field_type, field_name, visible, wire, auto): + ''' + Default method for making a data type a member of a structure. + Extend this if the data type needs to add an additional length field or something. + + module is the global module object. + complex_type is the structure object. + see Field for the meaning of the other parameters. + ''' + new_field = Field(self, field_type, field_name, visible, wire, auto) + + # We dump the _placeholder_byte if any fields are added. + for (idx, field) in enumerate(complex_type.fields): + if field == _placeholder_byte: + complex_type.fields[idx] = new_field + return + + complex_type.fields.append(new_field) + + +class SimpleType(Type): + ''' + Derived class which represents a cardinal type like CARD32 or char. + Any type which is typedef'ed to cardinal will be one of these. + + Public fields added: + none + ''' + def __init__(self, name, size): + Type.__init__(self, name) + self.is_simple = True + self.size = size + self.nmemb = 1 + + def resolve(self, module): + self.resolved = True + + def fixed_size(self): + return True + + out = __main__.output['simple'] + + +# Cardinal datatype globals. See module __init__ method. +tcard8 = SimpleType(('uint8_t',), 1) +tcard16 = SimpleType(('uint16_t',), 2) +tcard32 = SimpleType(('uint32_t',), 4) +tint8 = SimpleType(('int8_t',), 1) +tint16 = SimpleType(('int16_t',), 2) +tint32 = SimpleType(('int32_t',), 4) +tchar = SimpleType(('char',), 1) +tfloat = SimpleType(('float',), 4) +tdouble = SimpleType(('double',), 8) + + +class Enum(SimpleType): + ''' + Derived class which represents an enum. Fixed-size. + + Public fields added: + values contains a list of (name, value) tuples. value is empty, or a number. + bits contains a list of (name, bitnum) tuples. items only appear if specified as a bit. bitnum is a number. + ''' + def __init__(self, name, elt): + SimpleType.__init__(self, name, 4) + self.values = [] + self.bits = [] + for item in list(elt): + # First check if we're using a default value + if len(list(item)) == 0: + self.values.append((item.get('name'), '')) + continue + + # An explicit value or bit was specified. + value = list(item)[0] + if value.tag == 'value': + self.values.append((item.get('name'), value.text)) + elif value.tag == 'bit': + self.values.append((item.get('name'), '%u' % (1 << int(value.text, 0)))) + self.bits.append((item.get('name'), value.text)) + + def resolve(self, module): + self.resolved = True + + def fixed_size(self): + return True + + out = __main__.output['enum'] + + +class ListType(Type): + ''' + Derived class which represents a list of some other datatype. Fixed- or variable-sized. + + Public fields added: + member is the datatype of the list elements. + parent is the structure type containing the list. + expr is an Expression object containing the length information, for variable-sized lists. + ''' + def __init__(self, elt, member, *parent): + Type.__init__(self, member.name) + self.is_list = True + self.member = member + self.parents = list(parent) + + if elt.tag == 'list': + elts = list(elt) + self.expr = Expression(elts[0] if len(elts) else elt, self) + elif elt.tag == 'valueparam': + self.expr = Expression(elt, self) + + self.size = member.size if member.fixed_size() else None + self.nmemb = self.expr.nmemb if self.expr.fixed_size() else None + + def make_member_of(self, module, complex_type, field_type, field_name, visible, wire, auto): + if not self.fixed_size(): + # We need a length field. + # Ask our Expression object for it's name, type, and whether it's on the wire. + lenfid = self.expr.lenfield_type + lenfield_name = self.expr.lenfield_name + lenwire = self.expr.lenwire + needlen = True + + # See if the length field is already in the structure. + for parent in self.parents: + for field in parent.fields: + if field.field_name == lenfield_name: + needlen = False + + # It isn't, so we need to add it to the structure ourself. + if needlen: + type = module.get_type(lenfid) + lenfield_type = module.get_type_name(lenfid) + type.make_member_of(module, complex_type, lenfield_type, lenfield_name, True, lenwire, False) + + # Add ourself to the structure by calling our original method. + Type.make_member_of(self, module, complex_type, field_type, field_name, visible, wire, auto) + + def resolve(self, module): + if self.resolved: + return + self.member.resolve(module) + self.expr.resolve(module, self.parents) + + # Find my length field again. We need the actual Field object in the expr. + # This is needed because we might have added it ourself above. + if not self.fixed_size(): + for parent in self.parents: + for field in parent.fields: + if field.field_name == self.expr.lenfield_name and field.wire: + self.expr.lenfield = field + break + + self.resolved = True + + def fixed_size(self): + return self.member.fixed_size() and self.expr.fixed_size() + +class ExprType(Type): + ''' + Derived class which represents an exprfield. Fixed size. + + Public fields added: + expr is an Expression object containing the value of the field. + ''' + def __init__(self, elt, member, *parent): + Type.__init__(self, member.name) + self.is_expr = True + self.member = member + self.parent = parent + + self.expr = Expression(list(elt)[0], self) + + self.size = member.size + self.nmemb = 1 + + def resolve(self, module): + if self.resolved: + return + self.member.resolve(module) + self.resolved = True + + def fixed_size(self): + return True + +class PadType(Type): + ''' + Derived class which represents a padding field. + ''' + def __init__(self, elt): + Type.__init__(self, tcard8.name) + self.is_pad = True + self.size = 1 + self.nmemb = 1 if (elt == None) else int(elt.get('bytes'), 0) + + def resolve(self, module): + self.resolved = True + + def fixed_size(self): + return True + + +class ComplexType(Type): + ''' + Derived class which represents a structure. Base type for all structure types. + + Public fields added: + fields is an array of Field objects describing the structure fields. + ''' + def __init__(self, name, elt): + Type.__init__(self, name) + self.is_container = True + self.elt = elt + self.fields = [] + self.nmemb = 1 + self.size = 0 + self.lenfield_parent = [self] + + def resolve(self, module): + if self.resolved: + return + pads = 0 + + # Resolve all of our field datatypes. + for child in list(self.elt): + if child.tag == 'pad': + field_name = 'pad' + str(pads) + fkey = 'CARD8' + type = PadType(child) + pads = pads + 1 + visible = False + elif child.tag == 'field': + field_name = child.get('name') + fkey = child.get('type') + type = module.get_type(fkey) + visible = True + elif child.tag == 'exprfield': + field_name = child.get('name') + fkey = child.get('type') + type = ExprType(child, module.get_type(fkey), *self.lenfield_parent) + visible = False + elif child.tag == 'list': + field_name = child.get('name') + fkey = child.get('type') + type = ListType(child, module.get_type(fkey), *self.lenfield_parent) + visible = True + elif child.tag == 'valueparam': + field_name = child.get('value-list-name') + fkey = 'CARD32' + type = ListType(child, module.get_type(fkey), *self.lenfield_parent) + visible = True + elif child.tag == 'switch': + field_name = child.get('name') + # construct the switch type name from the parent type and the field name + field_type = self.name + (field_name,) + type = SwitchType(field_type, child, *self.lenfield_parent) + visible = True + type.make_member_of(module, self, field_type, field_name, visible, True, False) + type.resolve(module) + continue + else: + # Hit this on Reply + continue + + # Get the full type name for the field + field_type = module.get_type_name(fkey) + # Add the field to ourself + type.make_member_of(module, self, field_type, field_name, visible, True, False) + # Recursively resolve the type (could be another structure, list) + type.resolve(module) + + self.calc_size() # Figure out how big we are + self.resolved = True + + def calc_size(self): + self.size = 0 + for m in self.fields: + if not m.wire: + continue + if m.type.fixed_size(): + self.size = self.size + (m.type.size * m.type.nmemb) + else: + self.size = None + break + + def fixed_size(self): + for m in self.fields: + if not m.type.fixed_size(): + return False + return True + +class SwitchType(ComplexType): + ''' + Derived class which represents a List of Items. + + Public fields added: + bitcases is an array of Bitcase objects describing the list items + ''' + + def __init__(self, name, elt, *parents): + ComplexType.__init__(self, name, elt) + self.parents = parents + # FIXME: switch cannot store lenfields, so it should just delegate the parents + self.lenfield_parent = list(parents) + [self] + # self.fields contains all possible fields collected from the Bitcase objects, + # whereas self.items contains the Bitcase objects themselves + self.bitcases = [] + + self.is_switch = True + elts = list(elt) + self.expr = Expression(elts[0] if len(elts) else elt, self) + + def resolve(self, module): + if self.resolved: + return +# pads = 0 + + parents = list(self.parents) + [self] + + # Resolve all of our field datatypes. + for index, child in enumerate(list(self.elt)): + if child.tag == 'bitcase': + field_name = child.get('name') + if field_name is None: + field_type = self.name + ('bitcase%d' % index,) + else: + field_type = self.name + (field_name,) + + # use self.parent to indicate anchestor, + # as switch does not contain named fields itself + type = BitcaseType(index, field_type, child, *parents) + # construct the switch type name from the parent type and the field name + if field_name is None: + type.has_name = False + # Get the full type name for the field + field_type = type.name + visible = True + + # add the field to ourself + type.make_member_of(module, self, field_type, field_name, visible, True, False) + + # recursively resolve the type (could be another structure, list) + type.resolve(module) + inserted = False + for new_field in type.fields: + # We dump the _placeholder_byte if any fields are added. + for (idx, field) in enumerate(self.fields): + if field == _placeholder_byte: + self.fields[idx] = new_field + inserted = True + break + if False == inserted: + self.fields.append(new_field) + + self.calc_size() # Figure out how big we are + self.resolved = True + + def make_member_of(self, module, complex_type, field_type, field_name, visible, wire, auto): + if not self.fixed_size(): + # We need a length field. + # Ask our Expression object for it's name, type, and whether it's on the wire. + lenfid = self.expr.lenfield_type + lenfield_name = self.expr.lenfield_name + lenwire = self.expr.lenwire + needlen = True + + # See if the length field is already in the structure. + for parent in self.parents: + for field in parent.fields: + if field.field_name == lenfield_name: + needlen = False + + # It isn't, so we need to add it to the structure ourself. + if needlen: + type = module.get_type(lenfid) + lenfield_type = module.get_type_name(lenfid) + type.make_member_of(module, complex_type, lenfield_type, lenfield_name, True, lenwire, False) + + # Add ourself to the structure by calling our original method. + Type.make_member_of(self, module, complex_type, field_type, field_name, visible, wire, auto) + + # size for switch can only be calculated at runtime + def calc_size(self): + pass + + # note: switch is _always_ of variable size, but we indicate here wether + # it contains elements that are variable-sized themselves + def fixed_size(self): + return False +# for m in self.fields: +# if not m.type.fixed_size(): +# return False +# return True + + +class Struct(ComplexType): + ''' + Derived class representing a struct data type. + ''' + out = __main__.output['struct'] + + +class Union(ComplexType): + ''' + Derived class representing a union data type. + ''' + def __init__(self, name, elt): + ComplexType.__init__(self, name, elt) + self.is_union = True + + out = __main__.output['union'] + + +class BitcaseType(ComplexType): + ''' + Derived class representing a struct data type. + ''' + def __init__(self, index, name, elt, *parent): + elts = list(elt) + self.expr = Expression(elts[0] if len(elts) else elt, self) + ComplexType.__init__(self, name, elts[1:]) + self.has_name = True + self.index = 1 + self.lenfield_parent = list(parent) + [self] + self.parents = list(parent) + self.is_bitcase = True + + def make_member_of(self, module, switch_type, field_type, field_name, visible, wire, auto): + ''' + register BitcaseType with the corresponding SwitchType + + module is the global module object. + complex_type is the structure object. + see Field for the meaning of the other parameters. + ''' + new_field = Field(self, field_type, field_name, visible, wire, auto) + + # We dump the _placeholder_byte if any bitcases are added. + for (idx, field) in enumerate(switch_type.bitcases): + if field == _placeholder_byte: + switch_type.bitcases[idx] = new_field + return + + switch_type.bitcases.append(new_field) + + def resolve(self, module): + if self.resolved: + return + + self.expr.resolve(module, self.parents+[self]) + + # Resolve the bitcase expression + ComplexType.resolve(self, module) + + +class Reply(ComplexType): + ''' + Derived class representing a reply. Only found as a field of Request. + ''' + def __init__(self, name, elt): + ComplexType.__init__(self, name, elt) + self.is_reply = True + + def resolve(self, module): + if self.resolved: + return + # Add the automatic protocol fields + self.fields.append(Field(tcard8, tcard8.name, 'response_type', False, True, True)) + self.fields.append(_placeholder_byte) + self.fields.append(Field(tcard16, tcard16.name, 'sequence', False, True, True)) + self.fields.append(Field(tcard32, tcard32.name, 'length', False, True, True)) + ComplexType.resolve(self, module) + + +class Request(ComplexType): + ''' + Derived class representing a request. + + Public fields added: + reply contains the reply datatype or None for void requests. + opcode contains the request number. + ''' + def __init__(self, name, elt): + ComplexType.__init__(self, name, elt) + self.reply = None + self.opcode = elt.get('opcode') + + for child in list(elt): + if child.tag == 'reply': + self.reply = Reply(name, child) + + def resolve(self, module): + if self.resolved: + return + # Add the automatic protocol fields + if module.namespace.is_ext: + self.fields.append(Field(tcard8, tcard8.name, 'major_opcode', False, True, True)) + self.fields.append(Field(tcard8, tcard8.name, 'minor_opcode', False, True, True)) + self.fields.append(Field(tcard16, tcard16.name, 'length', False, True, True)) + ComplexType.resolve(self, module) + else: + self.fields.append(Field(tcard8, tcard8.name, 'major_opcode', False, True, True)) + self.fields.append(_placeholder_byte) + self.fields.append(Field(tcard16, tcard16.name, 'length', False, True, True)) + ComplexType.resolve(self, module) + + if self.reply: + self.reply.resolve(module) + + out = __main__.output['request'] + + +class Event(ComplexType): + ''' + Derived class representing an event data type. + + Public fields added: + opcodes is a dictionary of name -> opcode number, for eventcopies. + ''' + def __init__(self, name, elt): + ComplexType.__init__(self, name, elt) + self.opcodes = {} + + tmp = elt.get('no-sequence-number') + self.has_seq = (tmp == None or tmp.lower() == 'false' or tmp == '0') + + def add_opcode(self, opcode, name, main): + self.opcodes[name] = opcode + if main: + self.name = name + + def resolve(self, module): + if self.resolved: + return + + # Add the automatic protocol fields + 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)) + ComplexType.resolve(self, module) + + out = __main__.output['event'] + + +class Error(ComplexType): + ''' + Derived class representing an error data type. + + Public fields added: + opcodes is a dictionary of name -> opcode number, for errorcopies. + ''' + def __init__(self, name, elt): + ComplexType.__init__(self, name, elt) + self.opcodes = {} + + def add_opcode(self, opcode, name, main): + self.opcodes[name] = opcode + if main: + self.name = name + + def resolve(self, module): + if self.resolved: + return + + # Add the automatic protocol fields + self.fields.append(Field(tcard8, tcard8.name, 'response_type', False, True, True)) + self.fields.append(Field(tcard8, tcard8.name, 'error_code', False, True, True)) + self.fields.append(Field(tcard16, tcard16.name, 'sequence', False, True, True)) + ComplexType.resolve(self, module) + + out = __main__.output['error'] + +_placeholder_byte = Field(PadType(None), tcard8.name, 'pad0', False, True, False) -- cgit v1.2.3