-#-------------------------------------------------------------------------------\r
-# elftools: port of OrderedDict to work on Python < 2.7\r
-#\r
-# Taken from http://code.activestate.com/recipes/576693/ , revision 9\r
-# Code by Raymond Hettinger. License: MIT\r
-#-------------------------------------------------------------------------------\r
-try:\r
- from thread import get_ident as _get_ident\r
-except ImportError:\r
- from dummy_thread import get_ident as _get_ident\r
-\r
-try:\r
- from _abcoll import KeysView, ValuesView, ItemsView\r
-except ImportError:\r
- pass\r
-\r
-\r
-class OrderedDict(dict):\r
- 'Dictionary that remembers insertion order'\r
- # An inherited dict maps keys to values.\r
- # The inherited dict provides __getitem__, __len__, __contains__, and get.\r
- # The remaining methods are order-aware.\r
- # Big-O running times for all methods are the same as for regular dictionaries.\r
-\r
- # The internal self.__map dictionary maps keys to links in a doubly linked list.\r
- # The circular doubly linked list starts and ends with a sentinel element.\r
- # The sentinel element never gets deleted (this simplifies the algorithm).\r
- # Each link is stored as a list of length three: [PREV, NEXT, KEY].\r
-\r
- def __init__(self, *args, **kwds):\r
- '''Initialize an ordered dictionary. Signature is the same as for\r
- regular dictionaries, but keyword arguments are not recommended\r
- because their insertion order is arbitrary.\r
-\r
- '''\r
- if len(args) > 1:\r
- raise TypeError('expected at most 1 arguments, got %d' % len(args))\r
- try:\r
- self.__root\r
- except AttributeError:\r
- self.__root = root = [] # sentinel node\r
- root[:] = [root, root, None]\r
- self.__map = {}\r
- self.__update(*args, **kwds)\r
-\r
- def __setitem__(self, key, value, dict_setitem=dict.__setitem__):\r
- 'od.__setitem__(i, y) <==> od[i]=y'\r
- # Setting a new item creates a new link which goes at the end of the linked\r
- # list, and the inherited dictionary is updated with the new key/value pair.\r
- if key not in self:\r
- root = self.__root\r
- last = root[0]\r
- last[1] = root[0] = self.__map[key] = [last, root, key]\r
- dict_setitem(self, key, value)\r
-\r
- def __delitem__(self, key, dict_delitem=dict.__delitem__):\r
- 'od.__delitem__(y) <==> del od[y]'\r
- # Deleting an existing item uses self.__map to find the link which is\r
- # then removed by updating the links in the predecessor and successor nodes.\r
- dict_delitem(self, key)\r
- link_prev, link_next, key = self.__map.pop(key)\r
- link_prev[1] = link_next\r
- link_next[0] = link_prev\r
-\r
- def __iter__(self):\r
- 'od.__iter__() <==> iter(od)'\r
- root = self.__root\r
- curr = root[1]\r
- while curr is not root:\r
- yield curr[2]\r
- curr = curr[1]\r
-\r
- def __reversed__(self):\r
- 'od.__reversed__() <==> reversed(od)'\r
- root = self.__root\r
- curr = root[0]\r
- while curr is not root:\r
- yield curr[2]\r
- curr = curr[0]\r
-\r
- def clear(self):\r
- 'od.clear() -> None. Remove all items from od.'\r
- try:\r
- for node in self.__map.itervalues():\r
- del node[:]\r
- root = self.__root\r
- root[:] = [root, root, None]\r
- self.__map.clear()\r
- except AttributeError:\r
- pass\r
- dict.clear(self)\r
-\r
- def popitem(self, last=True):\r
- '''od.popitem() -> (k, v), return and remove a (key, value) pair.\r
- Pairs are returned in LIFO order if last is true or FIFO order if false.\r
-\r
- '''\r
- if not self:\r
- raise KeyError('dictionary is empty')\r
- root = self.__root\r
- if last:\r
- link = root[0]\r
- link_prev = link[0]\r
- link_prev[1] = root\r
- root[0] = link_prev\r
- else:\r
- link = root[1]\r
- link_next = link[1]\r
- root[1] = link_next\r
- link_next[0] = root\r
- key = link[2]\r
- del self.__map[key]\r
- value = dict.pop(self, key)\r
- return key, value\r
-\r
- # -- the following methods do not depend on the internal structure --\r
-\r
- def keys(self):\r
- 'od.keys() -> list of keys in od'\r
- return list(self)\r
-\r
- def values(self):\r
- 'od.values() -> list of values in od'\r
- return [self[key] for key in self]\r
-\r
- def items(self):\r
- 'od.items() -> list of (key, value) pairs in od'\r
- return [(key, self[key]) for key in self]\r
-\r
- def iterkeys(self):\r
- 'od.iterkeys() -> an iterator over the keys in od'\r
- return iter(self)\r
-\r
- def itervalues(self):\r
- 'od.itervalues -> an iterator over the values in od'\r
- for k in self:\r
- yield self[k]\r
-\r
- def iteritems(self):\r
- 'od.iteritems -> an iterator over the (key, value) items in od'\r
- for k in self:\r
- yield (k, self[k])\r
-\r
- def update(*args, **kwds):\r
- '''od.update(E, **F) -> None. Update od from dict/iterable E and F.\r
-\r
- If E is a dict instance, does: for k in E: od[k] = E[k]\r
- If E has a .keys() method, does: for k in E.keys(): od[k] = E[k]\r
- Or if E is an iterable of items, does: for k, v in E: od[k] = v\r
- In either case, this is followed by: for k, v in F.items(): od[k] = v\r
-\r
- '''\r
- if len(args) > 2:\r
- raise TypeError('update() takes at most 2 positional '\r
- 'arguments (%d given)' % (len(args),))\r
- elif not args:\r
- raise TypeError('update() takes at least 1 argument (0 given)')\r
- self = args[0]\r
- # Make progressively weaker assumptions about "other"\r
- other = ()\r
- if len(args) == 2:\r
- other = args[1]\r
- if isinstance(other, dict):\r
- for key in other:\r
- self[key] = other[key]\r
- elif hasattr(other, 'keys'):\r
- for key in other.keys():\r
- self[key] = other[key]\r
- else:\r
- for key, value in other:\r
- self[key] = value\r
- for key, value in kwds.items():\r
- self[key] = value\r
-\r
- __update = update # let subclasses override update without breaking __init__\r
-\r
- __marker = object()\r
-\r
- def pop(self, key, default=__marker):\r
- '''od.pop(k[,d]) -> v, remove specified key and return the corresponding value.\r
- If key is not found, d is returned if given, otherwise KeyError is raised.\r
-\r
- '''\r
- if key in self:\r
- result = self[key]\r
- del self[key]\r
- return result\r
- if default is self.__marker:\r
- raise KeyError(key)\r
- return default\r
-\r
- def setdefault(self, key, default=None):\r
- 'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od'\r
- if key in self:\r
- return self[key]\r
- self[key] = default\r
- return default\r
-\r
- def __repr__(self, _repr_running={}):\r
- 'od.__repr__() <==> repr(od)'\r
- call_key = id(self), _get_ident()\r
- if call_key in _repr_running:\r
- return '...'\r
- _repr_running[call_key] = 1\r
- try:\r
- if not self:\r
- return '%s()' % (self.__class__.__name__,)\r
- return '%s(%r)' % (self.__class__.__name__, self.items())\r
- finally:\r
- del _repr_running[call_key]\r
-\r
- def __reduce__(self):\r
- 'Return state information for pickling'\r
- items = [[k, self[k]] for k in self]\r
- inst_dict = vars(self).copy()\r
- for k in vars(OrderedDict()):\r
- inst_dict.pop(k, None)\r
- if inst_dict:\r
- return (self.__class__, (items,), inst_dict)\r
- return self.__class__, (items,)\r
-\r
- def copy(self):\r
- 'od.copy() -> a shallow copy of od'\r
- return self.__class__(self)\r
-\r
- @classmethod\r
- def fromkeys(cls, iterable, value=None):\r
- '''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S\r
- and values equal to v (which defaults to None).\r
-\r
- '''\r
- d = cls()\r
- for key in iterable:\r
- d[key] = value\r
- return d\r
-\r
- def __eq__(self, other):\r
- '''od.__eq__(y) <==> od==y. Comparison to another OD is order-sensitive\r
- while comparison to a regular mapping is order-insensitive.\r
-\r
- '''\r
- if isinstance(other, OrderedDict):\r
- return len(self)==len(other) and self.items() == other.items()\r
- return dict.__eq__(self, other)\r
-\r
- def __ne__(self, other):\r
- return not self == other\r
-\r
- # -- the following methods are only used in Python 2.7 --\r
-\r
- def viewkeys(self):\r
- "od.viewkeys() -> a set-like object providing a view on od's keys"\r
- return KeysView(self)\r
-\r
- def viewvalues(self):\r
- "od.viewvalues() -> an object providing a view on od's values"\r
- return ValuesView(self)\r
-\r
- def viewitems(self):\r
- "od.viewitems() -> a set-like object providing a view on od's items"\r
- return ItemsView(self)\r
-\r
+#-------------------------------------------------------------------------------
+# elftools: port of OrderedDict to work on Python < 2.7
+#
+# Taken from http://code.activestate.com/recipes/576693/ , revision 9
+# Code by Raymond Hettinger. License: MIT
+#-------------------------------------------------------------------------------
+try:
+ from thread import get_ident as _get_ident
+except ImportError:
+ from dummy_thread import get_ident as _get_ident
+
+try:
+ from _abcoll import KeysView, ValuesView, ItemsView
+except ImportError:
+ pass
+
+
+class OrderedDict(dict):
+ 'Dictionary that remembers insertion order'
+ # An inherited dict maps keys to values.
+ # The inherited dict provides __getitem__, __len__, __contains__, and get.
+ # The remaining methods are order-aware.
+ # Big-O running times for all methods are the same as for regular dictionaries.
+
+ # The internal self.__map dictionary maps keys to links in a doubly linked list.
+ # The circular doubly linked list starts and ends with a sentinel element.
+ # The sentinel element never gets deleted (this simplifies the algorithm).
+ # Each link is stored as a list of length three: [PREV, NEXT, KEY].
+
+ def __init__(self, *args, **kwds):
+ '''Initialize an ordered dictionary. Signature is the same as for
+ regular dictionaries, but keyword arguments are not recommended
+ because their insertion order is arbitrary.
+
+ '''
+ if len(args) > 1:
+ raise TypeError('expected at most 1 arguments, got %d' % len(args))
+ try:
+ self.__root
+ except AttributeError:
+ self.__root = root = [] # sentinel node
+ root[:] = [root, root, None]
+ self.__map = {}
+ self.__update(*args, **kwds)
+
+ def __setitem__(self, key, value, dict_setitem=dict.__setitem__):
+ 'od.__setitem__(i, y) <==> od[i]=y'
+ # Setting a new item creates a new link which goes at the end of the linked
+ # list, and the inherited dictionary is updated with the new key/value pair.
+ if key not in self:
+ root = self.__root
+ last = root[0]
+ last[1] = root[0] = self.__map[key] = [last, root, key]
+ dict_setitem(self, key, value)
+
+ def __delitem__(self, key, dict_delitem=dict.__delitem__):
+ 'od.__delitem__(y) <==> del od[y]'
+ # Deleting an existing item uses self.__map to find the link which is
+ # then removed by updating the links in the predecessor and successor nodes.
+ dict_delitem(self, key)
+ link_prev, link_next, key = self.__map.pop(key)
+ link_prev[1] = link_next
+ link_next[0] = link_prev
+
+ def __iter__(self):
+ 'od.__iter__() <==> iter(od)'
+ root = self.__root
+ curr = root[1]
+ while curr is not root:
+ yield curr[2]
+ curr = curr[1]
+
+ def __reversed__(self):
+ 'od.__reversed__() <==> reversed(od)'
+ root = self.__root
+ curr = root[0]
+ while curr is not root:
+ yield curr[2]
+ curr = curr[0]
+
+ def clear(self):
+ 'od.clear() -> None. Remove all items from od.'
+ try:
+ for node in self.__map.itervalues():
+ del node[:]
+ root = self.__root
+ root[:] = [root, root, None]
+ self.__map.clear()
+ except AttributeError:
+ pass
+ dict.clear(self)
+
+ def popitem(self, last=True):
+ '''od.popitem() -> (k, v), return and remove a (key, value) pair.
+ Pairs are returned in LIFO order if last is true or FIFO order if false.
+
+ '''
+ if not self:
+ raise KeyError('dictionary is empty')
+ root = self.__root
+ if last:
+ link = root[0]
+ link_prev = link[0]
+ link_prev[1] = root
+ root[0] = link_prev
+ else:
+ link = root[1]
+ link_next = link[1]
+ root[1] = link_next
+ link_next[0] = root
+ key = link[2]
+ del self.__map[key]
+ value = dict.pop(self, key)
+ return key, value
+
+ # -- the following methods do not depend on the internal structure --
+
+ def keys(self):
+ 'od.keys() -> list of keys in od'
+ return list(self)
+
+ def values(self):
+ 'od.values() -> list of values in od'
+ return [self[key] for key in self]
+
+ def items(self):
+ 'od.items() -> list of (key, value) pairs in od'
+ return [(key, self[key]) for key in self]
+
+ def iterkeys(self):
+ 'od.iterkeys() -> an iterator over the keys in od'
+ return iter(self)
+
+ def itervalues(self):
+ 'od.itervalues -> an iterator over the values in od'
+ for k in self:
+ yield self[k]
+
+ def iteritems(self):
+ 'od.iteritems -> an iterator over the (key, value) items in od'
+ for k in self:
+ yield (k, self[k])
+
+ def update(*args, **kwds):
+ '''od.update(E, **F) -> None. Update od from dict/iterable E and F.
+
+ If E is a dict instance, does: for k in E: od[k] = E[k]
+ If E has a .keys() method, does: for k in E.keys(): od[k] = E[k]
+ Or if E is an iterable of items, does: for k, v in E: od[k] = v
+ In either case, this is followed by: for k, v in F.items(): od[k] = v
+
+ '''
+ if len(args) > 2:
+ raise TypeError('update() takes at most 2 positional '
+ 'arguments (%d given)' % (len(args),))
+ elif not args:
+ raise TypeError('update() takes at least 1 argument (0 given)')
+ self = args[0]
+ # Make progressively weaker assumptions about "other"
+ other = ()
+ if len(args) == 2:
+ other = args[1]
+ if isinstance(other, dict):
+ for key in other:
+ self[key] = other[key]
+ elif hasattr(other, 'keys'):
+ for key in other.keys():
+ self[key] = other[key]
+ else:
+ for key, value in other:
+ self[key] = value
+ for key, value in kwds.items():
+ self[key] = value
+
+ __update = update # let subclasses override update without breaking __init__
+
+ __marker = object()
+
+ def pop(self, key, default=__marker):
+ '''od.pop(k[,d]) -> v, remove specified key and return the corresponding value.
+ If key is not found, d is returned if given, otherwise KeyError is raised.
+
+ '''
+ if key in self:
+ result = self[key]
+ del self[key]
+ return result
+ if default is self.__marker:
+ raise KeyError(key)
+ return default
+
+ def setdefault(self, key, default=None):
+ 'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od'
+ if key in self:
+ return self[key]
+ self[key] = default
+ return default
+
+ def __repr__(self, _repr_running={}):
+ 'od.__repr__() <==> repr(od)'
+ call_key = id(self), _get_ident()
+ if call_key in _repr_running:
+ return '...'
+ _repr_running[call_key] = 1
+ try:
+ if not self:
+ return '%s()' % (self.__class__.__name__,)
+ return '%s(%r)' % (self.__class__.__name__, self.items())
+ finally:
+ del _repr_running[call_key]
+
+ def __reduce__(self):
+ 'Return state information for pickling'
+ items = [[k, self[k]] for k in self]
+ inst_dict = vars(self).copy()
+ for k in vars(OrderedDict()):
+ inst_dict.pop(k, None)
+ if inst_dict:
+ return (self.__class__, (items,), inst_dict)
+ return self.__class__, (items,)
+
+ def copy(self):
+ 'od.copy() -> a shallow copy of od'
+ return self.__class__(self)
+
+ @classmethod
+ def fromkeys(cls, iterable, value=None):
+ '''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S
+ and values equal to v (which defaults to None).
+
+ '''
+ d = cls()
+ for key in iterable:
+ d[key] = value
+ return d
+
+ def __eq__(self, other):
+ '''od.__eq__(y) <==> od==y. Comparison to another OD is order-sensitive
+ while comparison to a regular mapping is order-insensitive.
+
+ '''
+ if isinstance(other, OrderedDict):
+ return len(self)==len(other) and self.items() == other.items()
+ return dict.__eq__(self, other)
+
+ def __ne__(self, other):
+ return not self == other
+
+ # -- the following methods are only used in Python 2.7 --
+
+ def viewkeys(self):
+ "od.viewkeys() -> a set-like object providing a view on od's keys"
+ return KeysView(self)
+
+ def viewvalues(self):
+ "od.viewvalues() -> an object providing a view on od's values"
+ return ValuesView(self)
+
+ def viewitems(self):
+ "od.viewitems() -> a set-like object providing a view on od's items"
+ return ItemsView(self)
+
projects / pyelftools.git / commitdiff