def __init__(self, vm, addr=None, type_=None):
    self._vm = vm
    if addr is None:
        self._addr = self.alloc(vm, self.get_size())
    else:
        self._addr = addr
    if type_ is not None:
        self._type = type_
    if self._type is None:
        raise ValueError("Subclass MemType and define cls._type or pass "
                         "a type to the constructor")

@classmethod
def alloc(cls, vm, size):
    """Returns an allocated page of size @size if cls.allocator is set.
    Raises ValueError otherwise.
    """
    if cls.allocator is None:
        raise ValueError("Cannot provide None address to MemType() if"
                         "%s.set_allocator has not been called."
                         % __name__)
    return cls.allocator(vm, size)

def cast(self, other_type):
    """Cast this MemType to another MemType (same address, same vm,
    but different type). Return the casted MemType.
    @other_type: either a Type instance (other_type.lval is used) or a
        MemType subclass
    """
    if isinstance(other_type, Type):
        other_type = other_type.lval
    return other_type(self._vm, self.get_addr())

def cast_field(self, field, other_type):
    """In this implementation, @field is a field name"""
    if isinstance(other_type, Type):
        other_type = other_type.lval
    return other_type(self._vm, self.get_addr(field))

@classmethod
def gen_fields(cls, fields=None):
    """Generate the fields of this class (so that they can be accessed with
    self.<field_name>) from a @fields list, as described in the class doc.
    Useful in case of a type cyclic dependency. For example, the following
    is not possible in python:
        class A(MemStruct):
            fields = [("b", Ptr("I", B))]
        class B(MemStruct):
            fields = [("a", Ptr("I", A))]
    With gen_fields, the following is the legal equivalent:
        class A(MemStruct):
            pass
        class B(MemStruct):
            fields = [("a", Ptr("I", A))]
        A.gen_fields([("b", Ptr("I", B))])
    """
    if fields is not None:
        if cls.fields is not None:
            raise ValueError("Cannot regen fields of a class. Setting "
                             "cls.fields at class definition and calling "
                             "gen_fields are mutually exclusive.")
        cls.fields = fields
    if cls._type is None:
        if cls.fields is None:
            raise ValueError("Cannot create a MemStruct subclass without"
                             " a cls._type or a cls.fields")
        cls._type = cls._gen_type(cls.fields)
    if cls._type in DYN_MEM_STRUCT_CACHE:
        # FIXME: Maybe a warning would be better?
        raise RuntimeError("Another MemType has the same type as this "
                           "one. Use it instead.")
    # Register this class so that another one will not be created when
    # calling cls._type.lval
    DYN_MEM_STRUCT_CACHE[cls._type] = cls
    cls._gen_attributes()

def get_addr(self, field_name=None):
    """
    @field_name: (str, optional) the name of the field to get the
        address of
    """
    if field_name is not None:
        offset = self._type.get_offset(field_name)
    else:
        offset = 0
    return self._addr + offset

def get_field(self, name):
    """Get a field value by name.
    useless most of the time since fields are accessible via self.<name>.
    """
    return self._type.get_field(self._vm, self.get_addr(), name)

@classmethod
def get_offset(cls, field_name):
    """Shorthand for self.get_type().get_offset(field_name)."""
    return cls.get_type().get_offset(field_name)

def get_size(self):
    """Return the dynamic size of this structure (e.g. the size of an
    instance). Defaults to sizeof for this base class.
    For example, MemStr defines get_size but not sizeof, as an instance
    has a fixed size (at least its value has), but all the instance do not
    have the same size.
    """
    return self.sizeof()

@classmethod
def get_type(cls):
    """Returns the Type subclass instance representing the C type of this
    MemType.
    """
    return cls._type

def memset(self, byte='\x00'):
    """Fill the memory space of this MemType with @byte ('\x00' by
    default). The size is retrieved with self.get_size() (dynamic size).
    """
    # TODO: multibyte patterns
    if not isinstance(byte, str) or not len(byte) == 1:
        raise ValueError("byte must be a 1-lengthed str")
    self._vm.set_mem(self.get_addr(), byte * self.get_size())

def raw(self):
    """Raw binary (str) representation of the MemType as it is in
    memory.
    """
    return self._vm.get_mem(self.get_addr(), self.get_size())

@classmethod
def set_allocator(cls, alloc_func):
    """Set an allocator for this class; allows to instanciate statically
    sized MemTypes (i.e. sizeof() is implemented) without specifying the
    address (the object is allocated by @alloc_func in the vm).
    You may call set_allocator on specific MemType classes if you want
    to use a different allocator.
    @alloc_func: func(VmMngr) -> integer_address
    """
    cls.allocator = alloc_func

def set_field(self, name, val):
    """Set a field value by name. @val is the python value corresponding to
    this field type.
    useless most of the time since fields are accessible via self.<name>.
    """
    return self._type.set_field(self._vm, self.get_addr(), name, val)

@classmethod
def sizeof(cls):
    """Return the static size of this type. By default, it is the size
    of the underlying Type.
    """
    return cls._type.size

def __init__(self, vm, addr=None, type_=None):
    self._vm = vm
    if addr is None:
        self._addr = self.alloc(vm, self.get_size())
    else:
        self._addr = addr
    if type_ is not None:
        self._type = type_
    if self._type is None:
        raise ValueError("Subclass MemType and define cls._type or pass "
                         "a type to the constructor")

@classmethod
def alloc(cls, vm, size):
    """Returns an allocated page of size @size if cls.allocator is set.
    Raises ValueError otherwise.
    """
    if cls.allocator is None:
        raise ValueError("Cannot provide None address to MemType() if"
                         "%s.set_allocator has not been called."
                         % __name__)
    return cls.allocator(vm, size)

def cast(self, other_type):
    """Cast this MemType to another MemType (same address, same vm,
    but different type). Return the casted MemType.
    @other_type: either a Type instance (other_type.lval is used) or a
        MemType subclass
    """
    if isinstance(other_type, Type):
        other_type = other_type.lval
    return other_type(self._vm, self.get_addr())

def cast_field(self, field, other_type):
    """In this implementation, @field is a field name"""
    if isinstance(other_type, Type):
        other_type = other_type.lval
    return other_type(self._vm, self.get_addr(field))

@classmethod
def gen_fields(cls, fields=None):
    """Generate the fields of this class (so that they can be accessed with
    self.<field_name>) from a @fields list, as described in the class doc.
    Useful in case of a type cyclic dependency. For example, the following
    is not possible in python:
        class A(MemStruct):
            fields = [("b", Ptr("I", B))]
        class B(MemStruct):
            fields = [("a", Ptr("I", A))]
    With gen_fields, the following is the legal equivalent:
        class A(MemStruct):
            pass
        class B(MemStruct):
            fields = [("a", Ptr("I", A))]
        A.gen_fields([("b", Ptr("I", B))])
    """
    if fields is not None:
        if cls.fields is not None:
            raise ValueError("Cannot regen fields of a class. Setting "
                             "cls.fields at class definition and calling "
                             "gen_fields are mutually exclusive.")
        cls.fields = fields
    if cls._type is None:
        if cls.fields is None:
            raise ValueError("Cannot create a MemStruct subclass without"
                             " a cls._type or a cls.fields")
        cls._type = cls._gen_type(cls.fields)
    if cls._type in DYN_MEM_STRUCT_CACHE:
        # FIXME: Maybe a warning would be better?
        raise RuntimeError("Another MemType has the same type as this "
                           "one. Use it instead.")
    # Register this class so that another one will not be created when
    # calling cls._type.lval
    DYN_MEM_STRUCT_CACHE[cls._type] = cls
    cls._gen_attributes()

def get_addr(self, field_name=None):
    """
    @field_name: (str, optional) the name of the field to get the
        address of
    """
    if field_name is not None:
        offset = self._type.get_offset(field_name)
    else:
        offset = 0
    return self._addr + offset

def get_field(self, name):
    """Get a field value by name.
    useless most of the time since fields are accessible via self.<name>.
    """
    return self._type.get_field(self._vm, self.get_addr(), name)

@classmethod
def get_offset(cls, field_name):
    """Shorthand for self.get_type().get_offset(field_name)."""
    return cls.get_type().get_offset(field_name)

def get_size(self):
    """Return the dynamic size of this structure (e.g. the size of an
    instance). Defaults to sizeof for this base class.
    For example, MemStr defines get_size but not sizeof, as an instance
    has a fixed size (at least its value has), but all the instance do not
    have the same size.
    """
    return self.sizeof()

@classmethod
def get_type(cls):
    """Returns the Type subclass instance representing the C type of this
    MemType.
    """
    return cls._type

def memset(self, byte='\x00'):
    """Fill the memory space of this MemType with @byte ('\x00' by
    default). The size is retrieved with self.get_size() (dynamic size).
    """
    # TODO: multibyte patterns
    if not isinstance(byte, str) or not len(byte) == 1:
        raise ValueError("byte must be a 1-lengthed str")
    self._vm.set_mem(self.get_addr(), byte * self.get_size())

def raw(self):
    """Raw binary (str) representation of the MemType as it is in
    memory.
    """
    return self._vm.get_mem(self.get_addr(), self.get_size())

@classmethod
def set_allocator(cls, alloc_func):
    """Set an allocator for this class; allows to instanciate statically
    sized MemTypes (i.e. sizeof() is implemented) without specifying the
    address (the object is allocated by @alloc_func in the vm).
    You may call set_allocator on specific MemType classes if you want
    to use a different allocator.
    @alloc_func: func(VmMngr) -> integer_address
    """
    cls.allocator = alloc_func

def set_field(self, name, val):
    """Set a field value by name. @val is the python value corresponding to
    this field type.
    useless most of the time since fields are accessible via self.<name>.
    """
    return self._type.set_field(self._vm, self.get_addr(), name, val)

@classmethod
def sizeof(cls):
    """Return the static size of this type. By default, it is the size
    of the underlying Type.
    """
    return cls._type.size

def __init__(self, vm, addr=None, type_=None):
    self._vm = vm
    if addr is None:
        self._addr = self.alloc(vm, self.get_size())
    else:
        self._addr = addr
    if type_ is not None:
        self._type = type_
    if self._type is None:
        raise ValueError("Subclass MemType and define cls._type or pass "
                         "a type to the constructor")

@classmethod
def alloc(cls, vm, size):
    """Returns an allocated page of size @size if cls.allocator is set.
    Raises ValueError otherwise.
    """
    if cls.allocator is None:
        raise ValueError("Cannot provide None address to MemType() if"
                         "%s.set_allocator has not been called."
                         % __name__)
    return cls.allocator(vm, size)

def cast(self, other_type):
    """Cast this MemType to another MemType (same address, same vm,
    but different type). Return the casted MemType.
    @other_type: either a Type instance (other_type.lval is used) or a
        MemType subclass
    """
    if isinstance(other_type, Type):
        other_type = other_type.lval
    return other_type(self._vm, self.get_addr())

def cast_field(self, field, other_type):
    """In this implementation, @field is a field name"""
    if isinstance(other_type, Type):
        other_type = other_type.lval
    return other_type(self._vm, self.get_addr(field))

@classmethod
def gen_fields(cls, fields=None):
    """Generate the fields of this class (so that they can be accessed with
    self.<field_name>) from a @fields list, as described in the class doc.
    Useful in case of a type cyclic dependency. For example, the following
    is not possible in python:
        class A(MemStruct):
            fields = [("b", Ptr("I", B))]
        class B(MemStruct):
            fields = [("a", Ptr("I", A))]
    With gen_fields, the following is the legal equivalent:
        class A(MemStruct):
            pass
        class B(MemStruct):
            fields = [("a", Ptr("I", A))]
        A.gen_fields([("b", Ptr("I", B))])
    """
    if fields is not None:
        if cls.fields is not None:
            raise ValueError("Cannot regen fields of a class. Setting "
                             "cls.fields at class definition and calling "
                             "gen_fields are mutually exclusive.")
        cls.fields = fields
    if cls._type is None:
        if cls.fields is None:
            raise ValueError("Cannot create a MemStruct subclass without"
                             " a cls._type or a cls.fields")
        cls._type = cls._gen_type(cls.fields)
    if cls._type in DYN_MEM_STRUCT_CACHE:
        # FIXME: Maybe a warning would be better?
        raise RuntimeError("Another MemType has the same type as this "
                           "one. Use it instead.")
    # Register this class so that another one will not be created when
    # calling cls._type.lval
    DYN_MEM_STRUCT_CACHE[cls._type] = cls
    cls._gen_attributes()

def get_addr(self, field_name=None):
    """
    @field_name: (str, optional) the name of the field to get the
        address of
    """
    if field_name is not None:
        offset = self._type.get_offset(field_name)
    else:
        offset = 0
    return self._addr + offset

def get_field(self, name):
    """Get a field value by name.
    useless most of the time since fields are accessible via self.<name>.
    """
    return self._type.get_field(self._vm, self.get_addr(), name)

@classmethod
def get_offset(cls, field_name):
    """Shorthand for self.get_type().get_offset(field_name)."""
    return cls.get_type().get_offset(field_name)

def get_size(self):
    """Return the dynamic size of this structure (e.g. the size of an
    instance). Defaults to sizeof for this base class.
    For example, MemStr defines get_size but not sizeof, as an instance
    has a fixed size (at least its value has), but all the instance do not
    have the same size.
    """
    return self.sizeof()

@classmethod
def get_type(cls):
    """Returns the Type subclass instance representing the C type of this
    MemType.
    """
    return cls._type

def memset(self, byte='\x00'):
    """Fill the memory space of this MemType with @byte ('\x00' by
    default). The size is retrieved with self.get_size() (dynamic size).
    """
    # TODO: multibyte patterns
    if not isinstance(byte, str) or not len(byte) == 1:
        raise ValueError("byte must be a 1-lengthed str")
    self._vm.set_mem(self.get_addr(), byte * self.get_size())

def raw(self):
    """Raw binary (str) representation of the MemType as it is in
    memory.
    """
    return self._vm.get_mem(self.get_addr(), self.get_size())

@classmethod
def set_allocator(cls, alloc_func):
    """Set an allocator for this class; allows to instanciate statically
    sized MemTypes (i.e. sizeof() is implemented) without specifying the
    address (the object is allocated by @alloc_func in the vm).
    You may call set_allocator on specific MemType classes if you want
    to use a different allocator.
    @alloc_func: func(VmMngr) -> integer_address
    """
    cls.allocator = alloc_func

def set_field(self, name, val):
    """Set a field value by name. @val is the python value corresponding to
    this field type.
    useless most of the time since fields are accessible via self.<name>.
    """
    return self._type.set_field(self._vm, self.get_addr(), name, val)

@classmethod
def sizeof(cls):
    """Return the static size of this type. By default, it is the size
    of the underlying Type.
    """
    return cls._type.size

def __init__(self, vm, addr=None, type_=None):
    self._vm = vm
    if addr is None:
        self._addr = self.alloc(vm, self.get_size())
    else:
        self._addr = addr
    if type_ is not None:
        self._type = type_
    if self._type is None:
        raise ValueError("Subclass MemType and define cls._type or pass "
                         "a type to the constructor")

@classmethod
def alloc(cls, vm, size):
    """Returns an allocated page of size @size if cls.allocator is set.
    Raises ValueError otherwise.
    """
    if cls.allocator is None:
        raise ValueError("Cannot provide None address to MemType() if"
                         "%s.set_allocator has not been called."
                         % __name__)
    return cls.allocator(vm, size)

def cast(self, other_type):
    """Cast this MemType to another MemType (same address, same vm,
    but different type). Return the casted MemType.
    @other_type: either a Type instance (other_type.lval is used) or a
        MemType subclass
    """
    if isinstance(other_type, Type):
        other_type = other_type.lval
    return other_type(self._vm, self.get_addr())

def cast_field(self, field, other_type):
    """In this implementation, @field is a field name"""
    if isinstance(other_type, Type):
        other_type = other_type.lval
    return other_type(self._vm, self.get_addr(field))

@classmethod
def gen_fields(cls, fields=None):
    """Generate the fields of this class (so that they can be accessed with
    self.<field_name>) from a @fields list, as described in the class doc.
    Useful in case of a type cyclic dependency. For example, the following
    is not possible in python:
        class A(MemStruct):
            fields = [("b", Ptr("I", B))]
        class B(MemStruct):
            fields = [("a", Ptr("I", A))]
    With gen_fields, the following is the legal equivalent:
        class A(MemStruct):
            pass
        class B(MemStruct):
            fields = [("a", Ptr("I", A))]
        A.gen_fields([("b", Ptr("I", B))])
    """
    if fields is not None:
        if cls.fields is not None:
            raise ValueError("Cannot regen fields of a class. Setting "
                             "cls.fields at class definition and calling "
                             "gen_fields are mutually exclusive.")
        cls.fields = fields
    if cls._type is None:
        if cls.fields is None:
            raise ValueError("Cannot create a MemStruct subclass without"
                             " a cls._type or a cls.fields")
        cls._type = cls._gen_type(cls.fields)
    if cls._type in DYN_MEM_STRUCT_CACHE:
        # FIXME: Maybe a warning would be better?
        raise RuntimeError("Another MemType has the same type as this "
                           "one. Use it instead.")
    # Register this class so that another one will not be created when
    # calling cls._type.lval
    DYN_MEM_STRUCT_CACHE[cls._type] = cls
    cls._gen_attributes()

def get_addr(self, field_name=None):
    """
    @field_name: (str, optional) the name of the field to get the
        address of
    """
    if field_name is not None:
        offset = self._type.get_offset(field_name)
    else:
        offset = 0
    return self._addr + offset

def get_field(self, name):
    """Get a field value by name.
    useless most of the time since fields are accessible via self.<name>.
    """
    return self._type.get_field(self._vm, self.get_addr(), name)

@classmethod
def get_offset(cls, field_name):
    """Shorthand for self.get_type().get_offset(field_name)."""
    return cls.get_type().get_offset(field_name)

def get_size(self):
    """Return the dynamic size of this structure (e.g. the size of an
    instance). Defaults to sizeof for this base class.
    For example, MemStr defines get_size but not sizeof, as an instance
    has a fixed size (at least its value has), but all the instance do not
    have the same size.
    """
    return self.sizeof()

@classmethod
def get_type(cls):
    """Returns the Type subclass instance representing the C type of this
    MemType.
    """
    return cls._type

def memset(self, byte='\x00'):
    """Fill the memory space of this MemType with @byte ('\x00' by
    default). The size is retrieved with self.get_size() (dynamic size).
    """
    # TODO: multibyte patterns
    if not isinstance(byte, str) or not len(byte) == 1:
        raise ValueError("byte must be a 1-lengthed str")
    self._vm.set_mem(self.get_addr(), byte * self.get_size())

def raw(self):
    """Raw binary (str) representation of the MemType as it is in
    memory.
    """
    return self._vm.get_mem(self.get_addr(), self.get_size())

@classmethod
def set_allocator(cls, alloc_func):
    """Set an allocator for this class; allows to instanciate statically
    sized MemTypes (i.e. sizeof() is implemented) without specifying the
    address (the object is allocated by @alloc_func in the vm).
    You may call set_allocator on specific MemType classes if you want
    to use a different allocator.
    @alloc_func: func(VmMngr) -> integer_address
    """
    cls.allocator = alloc_func

def set_field(self, name, val):
    """Set a field value by name. @val is the python value corresponding to
    this field type.
    useless most of the time since fields are accessible via self.<name>.
    """
    return self._type.set_field(self._vm, self.get_addr(), name, val)

@classmethod
def sizeof(cls):
    """Return the static size of this type. By default, it is the size
    of the underlying Type.
    """
    return cls._type.size

def __init__(self, vm, addr=None, type_=None):
    self._vm = vm
    if addr is None:
        self._addr = self.alloc(vm, self.get_size())
    else:
        self._addr = addr
    if type_ is not None:
        self._type = type_
    if self._type is None:
        raise ValueError("Subclass MemType and define cls._type or pass "
                         "a type to the constructor")

@classmethod
def alloc(cls, vm, size):
    """Returns an allocated page of size @size if cls.allocator is set.
    Raises ValueError otherwise.
    """
    if cls.allocator is None:
        raise ValueError("Cannot provide None address to MemType() if"
                         "%s.set_allocator has not been called."
                         % __name__)
    return cls.allocator(vm, size)

def cast(self, other_type):
    """Cast this MemType to another MemType (same address, same vm,
    but different type). Return the casted MemType.
    @other_type: either a Type instance (other_type.lval is used) or a
        MemType subclass
    """
    if isinstance(other_type, Type):
        other_type = other_type.lval
    return other_type(self._vm, self.get_addr())

def cast_field(self, field, other_type):
    """In this implementation, @field is a field name"""
    if isinstance(other_type, Type):
        other_type = other_type.lval
    return other_type(self._vm, self.get_addr(field))

@classmethod
def gen_fields(cls, fields=None):
    """Generate the fields of this class (so that they can be accessed with
    self.<field_name>) from a @fields list, as described in the class doc.
    Useful in case of a type cyclic dependency. For example, the following
    is not possible in python:
        class A(MemStruct):
            fields = [("b", Ptr("I", B))]
        class B(MemStruct):
            fields = [("a", Ptr("I", A))]
    With gen_fields, the following is the legal equivalent:
        class A(MemStruct):
            pass
        class B(MemStruct):
            fields = [("a", Ptr("I", A))]
        A.gen_fields([("b", Ptr("I", B))])
    """
    if fields is not None:
        if cls.fields is not None:
            raise ValueError("Cannot regen fields of a class. Setting "
                             "cls.fields at class definition and calling "
                             "gen_fields are mutually exclusive.")
        cls.fields = fields
    if cls._type is None:
        if cls.fields is None:
            raise ValueError("Cannot create a MemStruct subclass without"
                             " a cls._type or a cls.fields")
        cls._type = cls._gen_type(cls.fields)
    if cls._type in DYN_MEM_STRUCT_CACHE:
        # FIXME: Maybe a warning would be better?
        raise RuntimeError("Another MemType has the same type as this "
                           "one. Use it instead.")
    # Register this class so that another one will not be created when
    # calling cls._type.lval
    DYN_MEM_STRUCT_CACHE[cls._type] = cls
    cls._gen_attributes()

def get_addr(self, field_name=None):
    """
    @field_name: (str, optional) the name of the field to get the
        address of
    """
    if field_name is not None:
        offset = self._type.get_offset(field_name)
    else:
        offset = 0
    return self._addr + offset

def get_field(self, name):
    """Get a field value by name.
    useless most of the time since fields are accessible via self.<name>.
    """
    return self._type.get_field(self._vm, self.get_addr(), name)

@classmethod
def get_offset(cls, field_name):
    """Shorthand for self.get_type().get_offset(field_name)."""
    return cls.get_type().get_offset(field_name)

def get_size(self):
    """Return the dynamic size of this structure (e.g. the size of an
    instance). Defaults to sizeof for this base class.
    For example, MemStr defines get_size but not sizeof, as an instance
    has a fixed size (at least its value has), but all the instance do not
    have the same size.
    """
    return self.sizeof()

@classmethod
def get_type(cls):
    """Returns the Type subclass instance representing the C type of this
    MemType.
    """
    return cls._type

def memset(self, byte='\x00'):
    """Fill the memory space of this MemType with @byte ('\x00' by
    default). The size is retrieved with self.get_size() (dynamic size).
    """
    # TODO: multibyte patterns
    if not isinstance(byte, str) or not len(byte) == 1:
        raise ValueError("byte must be a 1-lengthed str")
    self._vm.set_mem(self.get_addr(), byte * self.get_size())

def raw(self):
    """Raw binary (str) representation of the MemType as it is in
    memory.
    """
    return self._vm.get_mem(self.get_addr(), self.get_size())

@classmethod
def set_allocator(cls, alloc_func):
    """Set an allocator for this class; allows to instanciate statically
    sized MemTypes (i.e. sizeof() is implemented) without specifying the
    address (the object is allocated by @alloc_func in the vm).
    You may call set_allocator on specific MemType classes if you want
    to use a different allocator.
    @alloc_func: func(VmMngr) -> integer_address
    """
    cls.allocator = alloc_func

def set_field(self, name, val):
    """Set a field value by name. @val is the python value corresponding to
    this field type.
    useless most of the time since fields are accessible via self.<name>.
    """
    return self._type.set_field(self._vm, self.get_addr(), name, val)

@classmethod
def sizeof(cls):
    """Return the static size of this type. By default, it is the size
    of the underlying Type.
    """
    return cls._type.size

def __init__(self, vm, addr=None, type_=None):
    self._vm = vm
    if addr is None:
        self._addr = self.alloc(vm, self.get_size())
    else:
        self._addr = addr
    if type_ is not None:
        self._type = type_
    if self._type is None:
        raise ValueError("Subclass MemType and define cls._type or pass "
                         "a type to the constructor")

@classmethod
def alloc(cls, vm, size):
    """Returns an allocated page of size @size if cls.allocator is set.
    Raises ValueError otherwise.
    """
    if cls.allocator is None:
        raise ValueError("Cannot provide None address to MemType() if"
                         "%s.set_allocator has not been called."
                         % __name__)
    return cls.allocator(vm, size)

def cast(self, other_type):
    """Cast this MemType to another MemType (same address, same vm,
    but different type). Return the casted MemType.
    @other_type: either a Type instance (other_type.lval is used) or a
        MemType subclass
    """
    if isinstance(other_type, Type):
        other_type = other_type.lval
    return other_type(self._vm, self.get_addr())

def cast_field(self, field, other_type):
    """In this implementation, @field is a field name"""
    if isinstance(other_type, Type):
        other_type = other_type.lval
    return other_type(self._vm, self.get_addr(field))

@classmethod
def gen_fields(cls, fields=None):
    """Generate the fields of this class (so that they can be accessed with
    self.<field_name>) from a @fields list, as described in the class doc.
    Useful in case of a type cyclic dependency. For example, the following
    is not possible in python:
        class A(MemStruct):
            fields = [("b", Ptr("I", B))]
        class B(MemStruct):
            fields = [("a", Ptr("I", A))]
    With gen_fields, the following is the legal equivalent:
        class A(MemStruct):
            pass
        class B(MemStruct):
            fields = [("a", Ptr("I", A))]
        A.gen_fields([("b", Ptr("I", B))])
    """
    if fields is not None:
        if cls.fields is not None:
            raise ValueError("Cannot regen fields of a class. Setting "
                             "cls.fields at class definition and calling "
                             "gen_fields are mutually exclusive.")
        cls.fields = fields
    if cls._type is None:
        if cls.fields is None:
            raise ValueError("Cannot create a MemStruct subclass without"
                             " a cls._type or a cls.fields")
        cls._type = cls._gen_type(cls.fields)
    if cls._type in DYN_MEM_STRUCT_CACHE:
        # FIXME: Maybe a warning would be better?
        raise RuntimeError("Another MemType has the same type as this "
                           "one. Use it instead.")
    # Register this class so that another one will not be created when
    # calling cls._type.lval
    DYN_MEM_STRUCT_CACHE[cls._type] = cls
    cls._gen_attributes()

def get_addr(self, field_name=None):
    """
    @field_name: (str, optional) the name of the field to get the
        address of
    """
    if field_name is not None:
        offset = self._type.get_offset(field_name)
    else:
        offset = 0
    return self._addr + offset

def get_field(self, name):
    """Get a field value by name.
    useless most of the time since fields are accessible via self.<name>.
    """
    return self._type.get_field(self._vm, self.get_addr(), name)

@classmethod
def get_offset(cls, field_name):
    """Shorthand for self.get_type().get_offset(field_name)."""
    return cls.get_type().get_offset(field_name)

def get_size(self):
    """Return the dynamic size of this structure (e.g. the size of an
    instance). Defaults to sizeof for this base class.
    For example, MemStr defines get_size but not sizeof, as an instance
    has a fixed size (at least its value has), but all the instance do not
    have the same size.
    """
    return self.sizeof()

@classmethod
def get_type(cls):
    """Returns the Type subclass instance representing the C type of this
    MemType.
    """
    return cls._type

def memset(self, byte='\x00'):
    """Fill the memory space of this MemType with @byte ('\x00' by
    default). The size is retrieved with self.get_size() (dynamic size).
    """
    # TODO: multibyte patterns
    if not isinstance(byte, str) or not len(byte) == 1:
        raise ValueError("byte must be a 1-lengthed str")
    self._vm.set_mem(self.get_addr(), byte * self.get_size())

def raw(self):
    """Raw binary (str) representation of the MemType as it is in
    memory.
    """
    return self._vm.get_mem(self.get_addr(), self.get_size())

@classmethod
def set_allocator(cls, alloc_func):
    """Set an allocator for this class; allows to instanciate statically
    sized MemTypes (i.e. sizeof() is implemented) without specifying the
    address (the object is allocated by @alloc_func in the vm).
    You may call set_allocator on specific MemType classes if you want
    to use a different allocator.
    @alloc_func: func(VmMngr) -> integer_address
    """
    cls.allocator = alloc_func

def set_field(self, name, val):
    """Set a field value by name. @val is the python value corresponding to
    this field type.
    useless most of the time since fields are accessible via self.<name>.
    """
    return self._type.set_field(self._vm, self.get_addr(), name, val)

@classmethod
def sizeof(cls):
    """Return the static size of this type. By default, it is the size
    of the underlying Type.
    """
    return cls._type.size

def __init__(self, vm, addr=None, type_=None):
    self._vm = vm
    if addr is None:
        self._addr = self.alloc(vm, self.get_size())
    else:
        self._addr = addr
    if type_ is not None:
        self._type = type_
    if self._type is None:
        raise ValueError("Subclass MemType and define cls._type or pass "
                         "a type to the constructor")

@classmethod
def alloc(cls, vm, size):
    """Returns an allocated page of size @size if cls.allocator is set.
    Raises ValueError otherwise.
    """
    if cls.allocator is None:
        raise ValueError("Cannot provide None address to MemType() if"
                         "%s.set_allocator has not been called."
                         % __name__)
    return cls.allocator(vm, size)

def cast(self, other_type):
    """Cast this MemType to another MemType (same address, same vm,
    but different type). Return the casted MemType.
    @other_type: either a Type instance (other_type.lval is used) or a
        MemType subclass
    """
    if isinstance(other_type, Type):
        other_type = other_type.lval
    return other_type(self._vm, self.get_addr())

def cast_field(self, field, other_type):
    """In this implementation, @field is a field name"""
    if isinstance(other_type, Type):
        other_type = other_type.lval
    return other_type(self._vm, self.get_addr(field))

@classmethod
def gen_fields(cls, fields=None):
    """Generate the fields of this class (so that they can be accessed with
    self.<field_name>) from a @fields list, as described in the class doc.
    Useful in case of a type cyclic dependency. For example, the following
    is not possible in python:
        class A(MemStruct):
            fields = [("b", Ptr("I", B))]
        class B(MemStruct):
            fields = [("a", Ptr("I", A))]
    With gen_fields, the following is the legal equivalent:
        class A(MemStruct):
            pass
        class B(MemStruct):
            fields = [("a", Ptr("I", A))]
        A.gen_fields([("b", Ptr("I", B))])
    """
    if fields is not None:
        if cls.fields is not None:
            raise ValueError("Cannot regen fields of a class. Setting "
                             "cls.fields at class definition and calling "
                             "gen_fields are mutually exclusive.")
        cls.fields = fields
    if cls._type is None:
        if cls.fields is None:
            raise ValueError("Cannot create a MemStruct subclass without"
                             " a cls._type or a cls.fields")
        cls._type = cls._gen_type(cls.fields)
    if cls._type in DYN_MEM_STRUCT_CACHE:
        # FIXME: Maybe a warning would be better?
        raise RuntimeError("Another MemType has the same type as this "
                           "one. Use it instead.")
    # Register this class so that another one will not be created when
    # calling cls._type.lval
    DYN_MEM_STRUCT_CACHE[cls._type] = cls
    cls._gen_attributes()

def get_addr(self, field_name=None):
    """
    @field_name: (str, optional) the name of the field to get the
        address of
    """
    if field_name is not None:
        offset = self._type.get_offset(field_name)
    else:
        offset = 0
    return self._addr + offset

def get_field(self, name):
    """Get a field value by name.
    useless most of the time since fields are accessible via self.<name>.
    """
    return self._type.get_field(self._vm, self.get_addr(), name)

@classmethod
def get_offset(cls, field_name):
    """Shorthand for self.get_type().get_offset(field_name)."""
    return cls.get_type().get_offset(field_name)

def get_size(self):
    """Return the dynamic size of this structure (e.g. the size of an
    instance). Defaults to sizeof for this base class.
    For example, MemStr defines get_size but not sizeof, as an instance
    has a fixed size (at least its value has), but all the instance do not
    have the same size.
    """
    return self.sizeof()

@classmethod
def get_type(cls):
    """Returns the Type subclass instance representing the C type of this
    MemType.
    """
    return cls._type

def memset(self, byte='\x00'):
    """Fill the memory space of this MemType with @byte ('\x00' by
    default). The size is retrieved with self.get_size() (dynamic size).
    """
    # TODO: multibyte patterns
    if not isinstance(byte, str) or not len(byte) == 1:
        raise ValueError("byte must be a 1-lengthed str")
    self._vm.set_mem(self.get_addr(), byte * self.get_size())

def raw(self):
    """Raw binary (str) representation of the MemType as it is in
    memory.
    """
    return self._vm.get_mem(self.get_addr(), self.get_size())

@classmethod
def set_allocator(cls, alloc_func):
    """Set an allocator for this class; allows to instanciate statically
    sized MemTypes (i.e. sizeof() is implemented) without specifying the
    address (the object is allocated by @alloc_func in the vm).
    You may call set_allocator on specific MemType classes if you want
    to use a different allocator.
    @alloc_func: func(VmMngr) -> integer_address
    """
    cls.allocator = alloc_func

def set_field(self, name, val):
    """Set a field value by name. @val is the python value corresponding to
    this field type.
    useless most of the time since fields are accessible via self.<name>.
    """
    return self._type.set_field(self._vm, self.get_addr(), name, val)

@classmethod
def sizeof(cls):
    """Return the static size of this type. By default, it is the size
    of the underlying Type.
    """
    return cls._type.size