'''
This module contains the classes which represent XCB data types.
'''
-from expr import Field, Expression
+from xcbgen.expr import Field, Expression
import __main__
class Type(object):
self.is_reply = False
self.is_union = False
self.is_pad = False
+ self.is_switch = False
+ self.is_bitcase = False
def resolve(self, module):
'''
'''
raise Exception('abstract fixed_size method not overridden!')
- def make_member_of(self, module, complex_type, field_type, field_name, visible, wire, auto):
+ def make_member_of(self, module, complex_type, field_type, field_name, visible, wire, auto, enum=None):
'''
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.
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)
+ new_field = Field(self, field_type, field_name, visible, wire, auto, enum)
# We dump the _placeholder_byte if any fields are added.
for (idx, field) in enumerate(complex_type.fields):
complex_type.fields.append(new_field)
+
class SimpleType(Type):
'''
Derived class which represents a cardinal type like CARD32 or char.
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 = []
+ self.doc = None
for item in list(elt):
+ if item.tag == 'doc':
+ self.doc = Doc(name, item)
+
# First check if we're using a default value
if len(list(item)) == 0:
self.values.append((item.get('name'), ''))
if value.tag == 'value':
self.values.append((item.get('name'), value.text))
elif value.tag == 'bit':
- # XXX replace this with a simple number, please.
- self.values.append((item.get('name'), '(1 << %s)' % value.text))
+ 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
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):
+ def __init__(self, elt, member, *parent):
Type.__init__(self, member.name)
self.is_list = True
self.member = member
- self.parent = parent
+ self.parents = list(parent)
if elt.tag == 'list':
elts = list(elt)
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):
+ def make_member_of(self, module, complex_type, field_type, field_name, visible, wire, auto, enum=None):
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.
needlen = True
# See if the length field is already in the structure.
- for field in self.parent.fields:
- if field.field_name == lenfield_name:
- needlen = False
+ 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)
+ type.make_member_of(module, complex_type, lenfield_type, lenfield_name, True, lenwire, False, enum)
# 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)
+ Type.make_member_of(self, module, complex_type, field_type, field_name, visible, wire, auto, enum)
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 field in self.parent.fields:
- if field.field_name == self.expr.lenfield_name and field.wire:
- self.expr.lenfield = field
- break
-
+ 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):
Public fields added:
expr is an Expression object containing the value of the field.
'''
- def __init__(self, elt, member, parent):
+ def __init__(self, elt, member, *parents):
Type.__init__(self, member.name)
self.is_expr = True
self.member = member
- self.parent = parent
+ self.parents = parents
self.expr = Expression(list(elt)[0], self)
Type.__init__(self, tcard8.name)
self.is_pad = True
self.size = 1
- self.nmemb = 1 if (elt == None) else int(elt.get('bytes'))
+ self.nmemb = 1 if (elt == None) else int(elt.get('bytes'), 0)
def resolve(self, module):
self.resolved = True
self.fields = []
self.nmemb = 1
self.size = 0
+ self.lenfield_parent = [self]
def resolve(self, module):
if self.resolved:
return
pads = 0
+ enum = None
# Resolve all of our field datatypes.
for child in list(self.elt):
visible = False
elif child.tag == 'field':
field_name = child.get('name')
+ enum = child.get('enum')
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)
+ 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)
+ 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)
+ 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)
+ type.make_member_of(module, self, field_type, field_name, visible, True, False, enum)
# Recursively resolve the type (could be another structure, list)
type.resolve(module)
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, enum=None):
+ 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, enum)
+
+ # 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, enum)
+
+ # 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):
'''
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 = []
+ fields = []
+ for elt in elts:
+ if elt.tag == 'enumref':
+ self.expr.append(Expression(elt, self))
+ else:
+ fields.append(elt)
+ ComplexType.__init__(self, name, fields)
+ 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, enum=None):
+ '''
+ 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, enum)
+
+ # 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
+
+ for e in self.expr:
+ e.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
+ self.doc = None
+
+ for child in list(elt):
+ if child.tag == 'doc':
+ self.doc = Doc(name, child)
def resolve(self, module):
if self.resolved:
def __init__(self, name, elt):
ComplexType.__init__(self, name, elt)
self.reply = None
+ self.doc = None
self.opcode = elt.get('opcode')
for child in list(elt):
if child.tag == 'reply':
self.reply = Reply(name, child)
+ if child.tag == 'doc':
+ self.doc = Doc(name, child)
def resolve(self, module):
if self.resolved:
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')
-
+ self.has_seq = not bool(elt.get('no-sequence-number'))
+
+ self.is_ge_event = bool(elt.get('xge'))
+
+ 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 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))
+
+ def add_ge_event_header():
+ self.fields.append(Field(tcard8, tcard8.name, 'response_type', False, True, True))
+ self.fields.append(Field(tcard8, tcard8.name, 'extension', False, True, True))
+ self.fields.append(Field(tcard16, tcard16.name, 'sequence', False, True, True))
+ self.fields.append(Field(tcard32, tcard32.name, 'length', False, True, True))
+ self.fields.append(Field(tcard16, tcard16.name, 'event_type', False, True, True))
+
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))
+ if self.is_ge_event:
+ add_ge_event_header()
+ else:
+ add_event_header()
+
ComplexType.resolve(self, module)
out = __main__.output['event']
out = __main__.output['error']
+
+class Doc(object):
+ '''
+ Class representing a <doc> tag.
+ '''
+ def __init__(self, name, elt):
+ self.name = name
+ self.description = None
+ self.brief = 'BRIEF DESCRIPTION MISSING'
+ self.fields = {}
+ self.errors = {}
+ self.see = {}
+ self.example = None
+
+ for child in list(elt):
+ text = child.text if child.text else ''
+ if child.tag == 'description':
+ self.description = text.strip()
+ if child.tag == 'brief':
+ self.brief = text.strip()
+ if child.tag == 'field':
+ self.fields[child.get('name')] = text.strip()
+ if child.tag == 'error':
+ self.errors[child.get('type')] = text.strip()
+ if child.tag == 'see':
+ self.see[child.get('name')] = child.get('type')
+ if child.tag == 'example':
+ self.example = text.strip()
+
+
+
_placeholder_byte = Field(PadType(None), tcard8.name, 'pad0', False, True, False)
projects / free-sw / xcb / proto / blobdiff