X-Git-Url: http://git.demorecorder.com/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=xcbgen%2Fxtypes.py;h=a4614d9d25035d0fdff844c38601ec1669b00fe8;hb=99cea12515da556b763f2a32b4b2dfa937552a20;hp=1a6c7ceed22e45d0b4214d584be5f3bf1115523f;hpb=76ca2c0b1527541be59c344118c538ba055ad9d8;p=free-sw%2Fxcb%2Fproto diff --git a/xcbgen/xtypes.py b/xcbgen/xtypes.py index 1a6c7ce..a4614d9 100644 --- a/xcbgen/xtypes.py +++ b/xcbgen/xtypes.py @@ -1,7 +1,7 @@ ''' 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): @@ -56,7 +56,7 @@ class Type(object): ''' 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. @@ -65,7 +65,7 @@ class Type(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) + 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): @@ -123,7 +123,11 @@ class Enum(SimpleType): 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'), '')) @@ -170,7 +174,7 @@ class ListType(Type): 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. @@ -189,10 +193,10 @@ class ListType(Type): 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: @@ -221,11 +225,11 @@ class ExprType(Type): 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) @@ -278,6 +282,7 @@ class ComplexType(Type): if self.resolved: return pads = 0 + enum = None # Resolve all of our field datatypes. for child in list(self.elt): @@ -289,6 +294,7 @@ class ComplexType(Type): 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 @@ -323,7 +329,7 @@ class ComplexType(Type): # 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) @@ -413,7 +419,7 @@ class SwitchType(ComplexType): 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): + 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. @@ -432,10 +438,10 @@ class SwitchType(ComplexType): 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) # size for switch can only be calculated at runtime def calc_size(self): @@ -475,15 +481,21 @@ class BitcaseType(ComplexType): ''' 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.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): + def make_member_of(self, module, switch_type, field_type, field_name, visible, wire, auto, enum=None): ''' register BitcaseType with the corresponding SwitchType @@ -491,7 +503,7 @@ class BitcaseType(ComplexType): 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 bitcases are added. for (idx, field) in enumerate(switch_type.bitcases): @@ -504,8 +516,9 @@ class BitcaseType(ComplexType): def resolve(self, module): if self.resolved: return - - self.expr.resolve(module, self.parents+[self]) + + for e in self.expr: + e.resolve(module, self.parents+[self]) # Resolve the bitcase expression ComplexType.resolve(self, module) @@ -518,6 +531,11 @@ class Reply(ComplexType): 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: @@ -541,11 +559,14 @@ class Request(ComplexType): 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: @@ -579,23 +600,43 @@ class Event(ComplexType): 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'] @@ -629,4 +670,35 @@ class Error(ComplexType): out = __main__.output['error'] + +class Doc(object): + ''' + Class representing a 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)