miasm2.core.utils module
import struct import inspect import UserDict from operator import itemgetter upck8 = lambda x: struct.unpack('B', x)[0] upck16 = lambda x: struct.unpack('H', x)[0] upck32 = lambda x: struct.unpack('I', x)[0] upck64 = lambda x: struct.unpack('Q', x)[0] pck8 = lambda x: struct.pack('B', x) pck16 = lambda x: struct.pack('H', x) pck32 = lambda x: struct.pack('I', x) pck64 = lambda x: struct.pack('Q', x) pck = {8: pck8, 16: pck16, 32: pck32, 64: pck64} def get_caller_name(caller_num=0): """Get the nth caller's name @caller_num: 0 = the caller of get_caller_name, 1 = next parent, ...""" pystk = inspect.stack() if len(pystk) > 1 + caller_num: return pystk[1 + caller_num][3] else: return "Bad caller num" def whoami(): """Returns the caller's name""" return get_caller_name(1) class Disasm_Exception(Exception): pass def hexdump(src, length=16): FILTER = ''.join( [(len(repr(chr(x))) == 3) and chr(x) or '.' for x in range(256)]) lines = [] for c in xrange(0, len(src), length): chars = src[c:c + length] hexa = ' '.join(["%02x" % ord(x) for x in chars]) printable = ''.join( ["%s" % ((ord(x) <= 127 and FILTER[ord(x)]) or '.') for x in chars]) lines.append("%04x %-*s %s\n" % (c, length * 3, hexa, printable)) print ''.join(lines) # stackoverflow.com/questions/2912231 import collections class keydefaultdict(collections.defaultdict): def __missing__(self, key): if self.default_factory is None: raise KeyError(key) value = self[key] = self.default_factory(key) return value class BoundedDict(UserDict.DictMixin): """Limited in size dictionary. To reduce combinatory cost, once an upper limit @max_size is reached, @max_size - @min_size elements are suppressed. The targeted elements are the less accessed. One can define a callback called when an element is removed """ def __init__(self, max_size, min_size=None, initialdata=None, delete_cb=None): """Create a BoundedDict @max_size: maximum size of the dictionary @min_size: (optional) number of most used element to keep when resizing @initialdata: (optional) dict instance with initial data @delete_cb: (optional) callback called when an element is removed """ self._data = initialdata.copy() if initialdata else {} self._min_size = min_size if min_size else max_size / 3 self._max_size = max_size self._size = len(self._data) # Do not use collections.Counter as it is quite slow self._counter = {k: 1 for k in self._data} self._delete_cb = delete_cb def __setitem__(self, asked_key, value): if asked_key not in self._data: # Update internal size and use's counter self._size += 1 # Bound can only be reached on a new element if (self._size >= self._max_size): most_common = sorted(self._counter.iteritems(), key=itemgetter(1), reverse=True) # Handle callback if self._delete_cb is not None: for key, _ in most_common[self._min_size - 1:]: self._delete_cb(key) # Keep only the most @_min_size used self._data = {key: self._data[key] for key, _ in most_common[:self._min_size - 1]} self._size = self._min_size # Reset use's counter self._counter = {k: 1 for k in self._data} # Avoid rechecking in dict: set to 1 here, add 1 otherwise self._counter[asked_key] = 1 else: self._counter[asked_key] += 1 self._data[asked_key] = value def __contains__(self, key): # Do not call has_key to avoid adding function call overhead return key in self._data def has_key(self, key): return key in self._data def keys(self): "Return the list of dict's keys" return self._data.keys() @property def data(self): "Return the current instance as a dictionary" return self._data def __getitem__(self, key): # Retrieve data first to raise the proper exception on error data = self._data[key] # Should never raise, since the key is in self._data self._counter[key] += 1 return data def __delitem__(self, key): if self._delete_cb is not None: self._delete_cb(key) del self._data[key] self._size -= 1 del self._counter[key] def __del__(self): """Ensure the callback is called when last reference is lost""" if self._delete_cb: for key in self._data: self._delete_cb(key)
Module variables
var pck
Functions
def get_caller_name(
caller_num=0)
Get the nth caller's name @caller_num: 0 = the caller of get_caller_name, 1 = next parent, ...
def get_caller_name(caller_num=0): """Get the nth caller's name @caller_num: 0 = the caller of get_caller_name, 1 = next parent, ...""" pystk = inspect.stack() if len(pystk) > 1 + caller_num: return pystk[1 + caller_num][3] else: return "Bad caller num"
def hexdump(
src, length=16)
def hexdump(src, length=16): FILTER = ''.join( [(len(repr(chr(x))) == 3) and chr(x) or '.' for x in range(256)]) lines = [] for c in xrange(0, len(src), length): chars = src[c:c + length] hexa = ' '.join(["%02x" % ord(x) for x in chars]) printable = ''.join( ["%s" % ((ord(x) <= 127 and FILTER[ord(x)]) or '.') for x in chars]) lines.append("%04x %-*s %s\n" % (c, length * 3, hexa, printable)) print ''.join(lines)
def pck16(
x)
pck16 = lambda x: struct.pack('H', x)
def pck32(
x)
pck32 = lambda x: struct.pack('I', x)
def pck64(
x)
pck64 = lambda x: struct.pack('Q', x)
def pck8(
x)
pck8 = lambda x: struct.pack('B', x)
def upck16(
x)
upck16 = lambda x: struct.unpack('H', x)[0]
def upck32(
x)
upck32 = lambda x: struct.unpack('I', x)[0]
def upck64(
x)
upck64 = lambda x: struct.unpack('Q', x)[0]
def upck8(
x)
upck8 = lambda x: struct.unpack('B', x)[0]
def whoami(
)
Returns the caller's name
def whoami(): """Returns the caller's name""" return get_caller_name(1)
Classes
class BoundedDict
Limited in size dictionary.
To reduce combinatory cost, once an upper limit @max_size is reached, @max_size - @min_size elements are suppressed. The targeted elements are the less accessed.
One can define a callback called when an element is removed
class BoundedDict(UserDict.DictMixin): """Limited in size dictionary. To reduce combinatory cost, once an upper limit @max_size is reached, @max_size - @min_size elements are suppressed. The targeted elements are the less accessed. One can define a callback called when an element is removed """ def __init__(self, max_size, min_size=None, initialdata=None, delete_cb=None): """Create a BoundedDict @max_size: maximum size of the dictionary @min_size: (optional) number of most used element to keep when resizing @initialdata: (optional) dict instance with initial data @delete_cb: (optional) callback called when an element is removed """ self._data = initialdata.copy() if initialdata else {} self._min_size = min_size if min_size else max_size / 3 self._max_size = max_size self._size = len(self._data) # Do not use collections.Counter as it is quite slow self._counter = {k: 1 for k in self._data} self._delete_cb = delete_cb def __setitem__(self, asked_key, value): if asked_key not in self._data: # Update internal size and use's counter self._size += 1 # Bound can only be reached on a new element if (self._size >= self._max_size): most_common = sorted(self._counter.iteritems(), key=itemgetter(1), reverse=True) # Handle callback if self._delete_cb is not None: for key, _ in most_common[self._min_size - 1:]: self._delete_cb(key) # Keep only the most @_min_size used self._data = {key: self._data[key] for key, _ in most_common[:self._min_size - 1]} self._size = self._min_size # Reset use's counter self._counter = {k: 1 for k in self._data} # Avoid rechecking in dict: set to 1 here, add 1 otherwise self._counter[asked_key] = 1 else: self._counter[asked_key] += 1 self._data[asked_key] = value def __contains__(self, key): # Do not call has_key to avoid adding function call overhead return key in self._data def has_key(self, key): return key in self._data def keys(self): "Return the list of dict's keys" return self._data.keys() @property def data(self): "Return the current instance as a dictionary" return self._data def __getitem__(self, key): # Retrieve data first to raise the proper exception on error data = self._data[key] # Should never raise, since the key is in self._data self._counter[key] += 1 return data def __delitem__(self, key): if self._delete_cb is not None: self._delete_cb(key) del self._data[key] self._size -= 1 del self._counter[key] def __del__(self): """Ensure the callback is called when last reference is lost""" if self._delete_cb: for key in self._data: self._delete_cb(key)
Ancestors (in MRO)
- BoundedDict
- UserDict.DictMixin
Instance variables
var data
Return the current instance as a dictionary
Methods
def __init__(
self, max_size, min_size=None, initialdata=None, delete_cb=None)
Create a BoundedDict @max_size: maximum size of the dictionary @min_size: (optional) number of most used element to keep when resizing @initialdata: (optional) dict instance with initial data @delete_cb: (optional) callback called when an element is removed
def __init__(self, max_size, min_size=None, initialdata=None, delete_cb=None): """Create a BoundedDict @max_size: maximum size of the dictionary @min_size: (optional) number of most used element to keep when resizing @initialdata: (optional) dict instance with initial data @delete_cb: (optional) callback called when an element is removed """ self._data = initialdata.copy() if initialdata else {} self._min_size = min_size if min_size else max_size / 3 self._max_size = max_size self._size = len(self._data) # Do not use collections.Counter as it is quite slow self._counter = {k: 1 for k in self._data} self._delete_cb = delete_cb
def clear(
self)
def clear(self): for key in self.keys(): del self[key]
def get(
self, key, default=None)
def get(self, key, default=None): try: return self[key] except KeyError: return default
def has_key(
self, key)
def has_key(self, key): return key in self._data
def items(
self)
def items(self): return list(self.iteritems())
def iteritems(
self)
def iteritems(self): for k in self: yield (k, self[k])
def iterkeys(
self)
def iterkeys(self): return self.__iter__()
def itervalues(
self)
def itervalues(self): for _, v in self.iteritems(): yield v
def keys(
self)
Return the list of dict's keys
def keys(self): "Return the list of dict's keys" return self._data.keys()
def pop(
self, key, *args)
def pop(self, key, *args): if len(args) > 1: raise TypeError, "pop expected at most 2 arguments, got "\ + repr(1 + len(args)) try: value = self[key] except KeyError: if args: return args[0] raise del self[key] return value
def popitem(
self)
def popitem(self): try: k, v = self.iteritems().next() except StopIteration: raise KeyError, 'container is empty' del self[k] return (k, v)
def setdefault(
self, key, default=None)
def setdefault(self, key, default=None): try: return self[key] except KeyError: self[key] = default return default
def update(
self, other=None, **kwargs)
def update(self, other=None, **kwargs): # Make progressively weaker assumptions about "other" if other is None: pass elif hasattr(other, 'iteritems'): # iteritems saves memory and lookups for k, v in other.iteritems(): self[k] = v elif hasattr(other, 'keys'): for k in other.keys(): self[k] = other[k] else: for k, v in other: self[k] = v if kwargs: self.update(kwargs)
def values(
self)
def values(self): return [v for _, v in self.iteritems()]
class Disasm_Exception
class Disasm_Exception(Exception): pass
Ancestors (in MRO)
- Disasm_Exception
- exceptions.Exception
- exceptions.BaseException
- __builtin__.object
Class variables
var args
var message
class keydefaultdict
class keydefaultdict(collections.defaultdict): def __missing__(self, key): if self.default_factory is None: raise KeyError(key) value = self[key] = self.default_factory(key) return value
Ancestors (in MRO)
- keydefaultdict
- collections.defaultdict
- __builtin__.dict
- __builtin__.object
Class variables
var default_factory