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 __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) self.size = member.size if member.fixed_size() else None self.nmemb = self.expr.nmemb if self.expr.fixed_size() else None
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
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, 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 self.expr.resolve(module, self.parents + [self]) # Resolve the bitcase expression ComplexType.resolve(self, module)
def __init__(self, elt, member, *parents): PrimitiveType.__init__(self, member.name, member.size) self.is_expr = True self.member = member self.parents = parents self.expr = Expression(list(elt)[0], self)
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 __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 __init__(self, elt, member, *parent): Type.__init__(self, member.name) self.is_list = True self.member = member self.parents = list(parent) lenfield_name = False if elt.tag == 'list': elts = list(elt) self.expr = Expression(elts[0] if len(elts) else elt, self) is_list_in_parent = self.parents[0].elt.tag in ('request', 'event', 'reply', 'error') if not len(elts) and is_list_in_parent: self.expr = Expression(elt,self) self.expr.op = 'calculate_len' else: self.expr = Expression(elts[0] if len(elts) else elt, self) self.size = member.size if member.fixed_size() else None self.nmemb = self.expr.nmemb if self.expr.fixed_size() else None self.required_start_align = self.member.required_start_align
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, 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 self.expr.resolve(module, self.parents+[self]) # Resolve the bitcase expression ComplexType.resolve(self, module)
def __init__(self, index, name, elt, *parent): elts = list(elt) self.expr = [] for sub_elt in elts: if sub_elt.tag == 'enumref': self.expr.append(Expression(sub_elt, self)) elt.remove(sub_elt) ComplexType.__init__(self, name, elt) self.has_name = True self.index = 1 self.lenfield_parent = list(parent) + [self] self.parents = list(parent) self.is_case_or_bitcase = True
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 __init__(self, elt, member, *parent): Type.__init__(self, member.name) self.is_list = True self.member = member self.parents = list(parent) lenfield_name = False if elt.tag == 'list': elts = list(elt) self.expr = Expression(elts[0] if len(elts) else elt, self) is_list_in_parent = self.parents[0].elt.tag in ('request', 'event', 'reply', 'error') if not len(elts) and is_list_in_parent: self.expr = Expression(elt, self) self.expr.op = 'calculate_len' else: self.expr = Expression(elts[0] if len(elts) else elt, self) self.size = member.size if member.fixed_size() else None self.nmemb = self.expr.nmemb if self.expr.fixed_size() else None self.required_start_align = self.member.required_start_align
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) 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, 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) 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 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) lenfield_name = False if elt.tag == 'list': elts = list(elt) self.expr = Expression(elts[0] if len(elts) else elt, self) is_list_in_parent = self.parents[0].elt.tag in ('request', 'event', 'reply', 'error') if not len(elts) and is_list_in_parent: self.expr = Expression(elt,self) self.expr.op = 'calculate_len' else: self.expr = Expression(elts[0] if len(elts) else elt, self) self.size = member.size if member.fixed_size() else None self.nmemb = self.expr.nmemb if self.expr.fixed_size() else None self.required_start_align = self.member.required_start_align 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) def resolve(self, module): if self.resolved: return self.member.resolve(module) self.expr.resolve(module, self.parents) self.required_start_align = self.member.required_start_align # 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() def unchecked_get_alignment_after(self, start_align, callstack, log): my_callstack = callstack[:] my_callstack.append(self) if start_align is None: log.fail(start_align, "", self, my_callstack, "start_align is None") return None if self.expr.fixed_size(): # fixed number of elements num_elements = self.nmemb prev_alignment = None alignment = start_align while num_elements > 0: if alignment is None: if log is not None: log.fail(start_align, "", self, my_callstack, ("fixed size list with size %d after %d iterations" + ", at transition from alignment \"%s\"") % (self.nmemb, (self.nmemb - num_elements), str(prev_alignment))) return None prev_alignment = alignment alignment = self.member.get_alignment_after(prev_alignment, my_callstack, log) num_elements -= 1 if log is not None: log.ok(start_align, "", self, my_callstack, alignment) return alignment else: # variable number of elements # check whether the number of elements is a multiple multiple = self.expr.get_multiple() assert multiple > 0 # iterate until the combined alignment does not change anymore alignment = start_align while True: prev_multiple_alignment = alignment # apply "multiple" amount of changes sequentially prev_alignment = alignment for multiple_count in range(0, multiple): after_alignment = self.member.get_alignment_after(prev_alignment, my_callstack, log) if after_alignment is None: if log is not None: log.fail(start_align, "", self, my_callstack, ("variable size list " + "at transition from alignment \"%s\"") % (str(prev_alignment))) return None prev_alignment = after_alignment # combine with the cumulatively combined alignment # (to model the variable number of entries) alignment = prev_multiple_alignment.combine_with(after_alignment) if alignment == prev_multiple_alignment: # does not change anymore by adding more potential elements # -> finished if log is not None: log.ok(start_align, "", self, my_callstack, alignment) return alignment
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) lenfield_name = False if elt.tag == 'list': elts = list(elt) self.expr = Expression(elts[0] if len(elts) else elt, self) is_list_in_parent = self.parents[0].elt.tag in ('request', 'event', 'reply', 'error') if not len(elts) and is_list_in_parent: self.expr = Expression(elt, self) self.expr.op = 'calculate_len' else: self.expr = Expression(elts[0] if len(elts) else elt, self) self.size = member.size if member.fixed_size() else None self.nmemb = self.expr.nmemb if self.expr.fixed_size() else None self.required_start_align = self.member.required_start_align 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) def resolve(self, module): if self.resolved: return self.member.resolve(module) self.expr.resolve(module, self.parents) self.required_start_align = self.member.required_start_align # 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() def unchecked_get_alignment_after(self, start_align, callstack, log): my_callstack = callstack[:] my_callstack.append(self) if start_align is None: log.fail(start_align, "", self, my_callstack, "start_align is None") return None if self.expr.fixed_size(): # fixed number of elements num_elements = self.nmemb prev_alignment = None alignment = start_align while num_elements > 0: if alignment is None: if log is not None: log.fail( start_align, "", self, my_callstack, ("fixed size list with size %d after %d iterations" + ", at transition from alignment \"%s\"") % (self.nmemb, (self.nmemb - num_elements), str(prev_alignment))) return None prev_alignment = alignment alignment = self.member.get_alignment_after( prev_alignment, my_callstack, log) num_elements -= 1 if log is not None: log.ok(start_align, "", self, my_callstack, alignment) return alignment else: # variable number of elements # check whether the number of elements is a multiple multiple = self.expr.get_multiple() assert multiple > 0 # iterate until the combined alignment does not change anymore alignment = start_align while True: prev_multiple_alignment = alignment # apply "multiple" amount of changes sequentially prev_alignment = alignment for multiple_count in range(0, multiple): after_alignment = self.member.get_alignment_after( prev_alignment, my_callstack, log) if after_alignment is None: if log is not None: log.fail(start_align, "", self, my_callstack, ("variable size list " + "at transition from alignment \"%s\"") % (str(prev_alignment))) return None prev_alignment = after_alignment # combine with the cumulatively combined alignment # (to model the variable number of entries) alignment = prev_multiple_alignment.combine_with( after_alignment) if alignment == prev_multiple_alignment: # does not change anymore by adding more potential elements # -> finished if log is not None: log.ok(start_align, "", self, my_callstack, alignment) return alignment