Fix up equality operators and had hash operators

1 files changed, 277 insertions, 252 deletions

diff --git a/python/binaryview.py b/python/binaryview.py
index 61500f06..fe94b0bf 100644
--- a/python/binaryview.py
+++ b/python/binaryview.py
@@ -137,13 +137,8 @@ class StringReference(object):
 		self._length = length
 		self._view = bv
 
-	@property
-	def value(self):
-		return self._view.read(self._start, self._length).decode(_decodings[self._type])
-
-	@property
-	def raw(self):
-		return self._view.read(self._start, self._length)
+	def __repr__(self):
+		return "<%s: %#x, len %#x>" % (self._type, self._start, self._length)
 
 	def __str__(self):
 		return pyNativeStr(self.raw)
@@ -151,8 +146,13 @@ class StringReference(object):
 	def __len__(self):
 		return self._length
 
-	def __repr__(self):
-		return "<%s: %#x, len %#x>" % (self._type, self._start, self._length)
+	@property
+	def value(self):
+		return self._view.read(self._start, self._length).decode(_decodings[self._type])
+
+	@property
+	def raw(self):
+		return self._view.read(self._start, self._length)
 
 	@property
 	def type(self):
@@ -694,15 +694,21 @@ class BinaryViewType(with_metaclass(_BinaryViewTypeMetaclass, object)):
 	def __init__(self, handle):
 		self.handle = core.handle_of_type(handle, core.BNBinaryViewType)
 
-	def __eq__(self, value):
-		if not isinstance(value, BinaryViewType):
-			return False
-		return ctypes.addressof(self.handle.contents) == ctypes.addressof(value.handle.contents)
+	def __repr__(self):
+		return "<view type: '%s'>" % self.name
 
-	def __ne__(self, value):
-		if not isinstance(value, BinaryViewType):
-			return True
-		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
+	def __eq__(self, other):
+		if not isinstance(other, self.__class__):
+			return NotImplemented
+		return ctypes.addressof(self.handle.contents) == ctypes.addressof(other.handle.contents)
+
+	def __ne__(self, other):
+		if not isinstance(other, self.__class__):
+			return NotImplemented
+		return not (self == other)
+
+	def __hash__(self):
+		return hash(ctypes.addressof(self.handle.contents))
 
 	@property
 	def list(self):
@@ -719,9 +725,6 @@ class BinaryViewType(with_metaclass(_BinaryViewTypeMetaclass, object)):
 		"""BinaryView long name (read-only)"""
 		return core.BNGetBinaryViewTypeLongName(self.handle)
 
-	def __repr__(self):
-		return "<view type: '%s'>" % self.name
-
 	def create(self, data):
 		view = core.BNCreateBinaryViewOfType(self.handle, data.handle)
 		if view is None:
@@ -902,6 +905,31 @@ class Segment(object):
 	def __init__(self, handle):
 		self.handle = handle
 
+	def __del__(self):
+		core.BNFreeSegment(self.handle)
+
+	def __repr__(self):
+		return "<segment: %#x-%#x, %s%s%s>" % (self.start, self.end,
+			"r" if self.readable else "-",
+			"w" if self.writable else "-",
+			"x" if self.executable else "-")
+
+	def __len__(self):
+		return core.BNSegmentGetLength(self.handle)
+
+	def __eq__(self, other):
+		if not isinstance(other, self.__class__):
+			return NotImplemented
+		return ctypes.addressof(self.handle.contents) == ctypes.addressof(other.handle.contents)
+
+	def __ne__(self, other):
+		if not isinstance(other, self.__class__):
+			return NotImplemented
+		return not (self == other)
+
+	def __hash__(self):
+		return hash(ctypes.addressof(self.handle.contents))
+
 	@property
 	def start(self):
 		return core.BNSegmentGetStart(self.handle)
@@ -965,36 +993,34 @@ class Segment(object):
 		core.BNFreeRelocationRanges(ranges, count)
 		return result
 
+
+
+class Section(object):
+	def __init__(self, handle):
+		self.handle = core.handle_of_type(handle, core.BNSection)
+
 	def __del__(self):
-		core.BNFreeSegment(self.handle)
+		core.BNFreeSection(self.handle)
+
+	def __repr__(self):
+		return "<section %s: %#x-%#x>" % (self.name, self.start, self.end)
+
+	def __len__(self):
+		return core.BNSectionGetLength(self.handle)
 
 	def __eq__(self, other):
-		if not isinstance(other, Segment):
-			return False
+		if not isinstance(other, self.__class__):
+			return NotImplemented
 		return ctypes.addressof(self.handle.contents) == ctypes.addressof(other.handle.contents)
 
 	def __ne__(self, other):
-		if not isinstance(other, Segment):
-			return False
-		return ctypes.addressof(self.handle.contents) != ctypes.addressof(other.handle.contents)
+		if not isinstance(other, self.__class__):
+			return NotImplemented
+		return not (self == other)
 
 	def __hash__(self):
 		return hash(ctypes.addressof(self.handle.contents))
 
-	def __len__(self):
-		return core.BNSegmentGetLength(self.handle)
-
-	def __repr__(self):
-		return "<segment: %#x-%#x, %s%s%s>" % (self.start, self.end,
-			"r" if self.readable else "-",
-			"w" if self.writable else "-",
-			"x" if self.executable else "-")
-
-
-class Section(object):
-	def __init__(self, handle):
-		self.handle = core.handle_of_type(handle, core.BNSection)
-
 	@property
 	def name(self):
 		return core.BNSectionGetName(self.handle)
@@ -1039,47 +1065,35 @@ class Section(object):
 	def end(self):
 		return self.start + len(self)
 
-	def __del__(self):
-		core.BNFreeSection(self.handle)
-
-	def __eq__(self, other):
-		if not isinstance(other, Section):
-			return False
-		return ctypes.addressof(self.handle.contents) == ctypes.addressof(other.handle.contents)
-
-	def __ne__(self, other):
-		if not isinstance(other, Section):
-			return False
-		return ctypes.addressof(self.handle.contents) != ctypes.addressof(other.handle.contents)
-
-	def __hash__(self):
-		return hash(ctypes.addressof(self.handle.contents))
-
-	def __len__(self):
-		return core.BNSectionGetLength(self.handle)
-
-	def __repr__(self):
-		return "<section %s: %#x-%#x>" % (self.name, self.start, self.end)
-
 
 class AddressRange(object):
 	def __init__(self, start, end):
 		self._start = start
 		self._end = end
 
+	def __repr__(self):
+		return "<%#x-%#x>" % (self._start, self._end)
+
 	def __len__(self):
 		return self._end - self.start
 
+	def __eq__(self, other):
+		if not isinstance(other, self.__class__):
+			return NotImplemented
+		return (self._start, self._end) == (other._start, other._end)
+
+	def __ne__(self, other):
+		if not isinstance(other, self.__class__):
+			return NotImplemented
+		return not (self == other)
+
+	def __hash__(self):
+		return hash((self._start, self._end))
+
 	@property
 	def length(self):
 		return self._end - self._start
 
-	def __len__(self):
-		return self._end - self._start
-
-	def __repr__(self):
-		return "<%#x-%#x>" % (self._start, self._end)
-
 	@property
 	def start(self):
 		""" """
@@ -1103,6 +1117,25 @@ class TagType(object):
 	def __init__(self, handle):
 		self.handle = core.handle_of_type(handle, core.BNTagType)
 
+	def __del__(self):
+		core.BNFreeTagType(self.handle)
+
+	def __repr__(self):
+		return "<tag type %s: %s>" % (self.name, self.icon)
+
+	def __eq__(self, other):
+		if not isinstance(other, self.__class__):
+			return NotImplemented
+		return ctypes.addressof(self.handle.contents) == ctypes.addressof(other.handle.contents)
+
+	def __ne__(self, other):
+		if not isinstance(other, self.__class__):
+			return NotImplemented
+		return not (self == other)
+
+	def __hash__(self):
+		return hash(ctypes.addressof(self.handle.contents))
+
 	@property
 	def name(self):
 		"""Name of the TagType"""
@@ -1139,30 +1172,31 @@ class TagType(object):
 	def type(self, value):
 		core.BNTagTypeSetType(self.handle, value)
 
+
+
+class Tag(object):
+	def __init__(self, handle):
+		self.handle = core.handle_of_type(handle, core.BNTag)
+
 	def __del__(self):
-		core.BNFreeTagType(self.handle)
+		core.BNFreeTag(self.handle)
+
+	def __repr__(self):
+		return "<tag %s %s: %s>" % (self.type.icon, self.type.name, self.data)
 
 	def __eq__(self, other):
-		if not isinstance(other, TagType):
-			return False
+		if not isinstance(other, self.__class__):
+			return NotImplemented
 		return ctypes.addressof(self.handle.contents) == ctypes.addressof(other.handle.contents)
 
 	def __ne__(self, other):
-		if not isinstance(other, TagType):
-			return False
-		return ctypes.addressof(self.handle.contents) != ctypes.addressof(other.handle.contents)
+		if not isinstance(other, self.__class__):
+			return NotImplemented
+		return not (self == other)
 
 	def __hash__(self):
 		return hash(ctypes.addressof(self.handle.contents))
 
-	def __repr__(self):
-		return "<tag type %s: %s>" % (self.name, self.icon)
-
-
-class Tag(object):
-	def __init__(self, handle):
-		self.handle = core.handle_of_type(handle, core.BNTag)
-
 	@property
 	def type(self):
 		return TagType(core.BNTagGetType(self.handle))
@@ -1175,25 +1209,6 @@ class Tag(object):
 	def data(self, value):
 		core.BNTagSetData(self.handle, value)
 
-	def __del__(self):
-		core.BNFreeTag(self.handle)
-
-	def __eq__(self, other):
-		if not isinstance(other, Tag):
-			return False
-		return ctypes.addressof(self.handle.contents) == ctypes.addressof(other.handle.contents)
-
-	def __ne__(self, other):
-		if not isinstance(other, Tag):
-			return False
-		return ctypes.addressof(self.handle.contents) != ctypes.addressof(other.handle.contents)
-
-	def __hash__(self):
-		return hash(self.handle.contents)
-
-	def __repr__(self):
-		return "<tag %s %s: %s>" % (self.type.icon, self.type.name, self.data)
-
 
 class _BinaryViewAssociatedDataStore(associateddatastore._AssociatedDataStore):
 	_defaults = {}
@@ -1302,15 +1317,108 @@ class BinaryView(object):
 		self._notifications = {}
 		self._next_address = None  # Do NOT try to access view before init() is called, use placeholder
 
-	def __eq__(self, value):
-		if not isinstance(value, BinaryView):
-			return False
-		return ctypes.addressof(self.handle.contents) == ctypes.addressof(value.handle.contents)
+	def __del__(self):
+		for i in self.notifications.values():
+			i._unregister()
+		core.BNFreeBinaryView(self.handle)
+
+	def __repr__(self):
+		start = self.start
+		length = len(self)
+		if start != 0:
+			size = "start %#x, len %#x" % (start, length)
+		else:
+			size = "len %#x" % length
+		filename = self._file.filename
+		if len(filename) > 0:
+			return "<BinaryView: '%s', %s>" % (filename, size)
+		return "<BinaryView: %s>" % (size)
+
+	def __len__(self):
+		return int(core.BNGetViewLength(self.handle))
+
+	def __eq__(self, other):
+		if not isinstance(other, self.__class__):
+			return NotImplemented
+		return ctypes.addressof(self.handle.contents) == ctypes.addressof(other.handle.contents)
 
-	def __ne__(self, value):
-		if not isinstance(value, BinaryView):
-			return True
-		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
+	def __ne__(self, other):
+		if not isinstance(other, self.__class__):
+			return NotImplemented
+		return not (self == other)
+
+	def __hash__(self):
+		return hash(ctypes.addressof(self.handle.contents))
+
+	def __iter__(self):
+		count = ctypes.c_ulonglong(0)
+		funcs = core.BNGetAnalysisFunctionList(self.handle, count)
+		try:
+			for i in range(0, count.value):
+				yield binaryninja.function.Function(self, core.BNNewFunctionReference(funcs[i]))
+		finally:
+			core.BNFreeFunctionList(funcs, count.value)
+
+
+	def __getitem__(self, i):
+		if isinstance(i, tuple):
+			result = bytes()
+			for s in i:
+				result += self.__getitem__(s)
+			return result
+		elif isinstance(i, slice):
+			if i.step is not None:
+				raise IndexError("step not implemented")
+			i = i.indices(self.end)
+			start = i[0]
+			stop = i[1]
+			if stop <= start:
+				return ""
+			return self.read(start, stop - start)
+		elif i < 0:
+			if i >= -len(self):
+				value = self.read(int(len(self) + i), 1)
+				if len(value) == 0:
+					return IndexError("index not readable")
+				return value
+			raise IndexError("index out of range")
+		elif (i >= self.start) and (i < self.end):
+			value = self.read(int(i), 1)
+			if len(value) == 0:
+				return IndexError("index not readable")
+			return value
+		else:
+			raise IndexError("index out of range")
+
+	def __setitem__(self, i, value):
+		if isinstance(i, slice):
+			if i.step is not None:
+				raise IndexError("step not supported on assignment")
+			i = i.indices(self.end)
+			start = i[0]
+			stop = i[1]
+			if stop < start:
+				stop = start
+			if len(value) != (stop - start):
+				self.remove(start, stop - start)
+				self.insert(start, value)
+			else:
+				self.write(start, value)
+		elif i < 0:
+			if i >= -len(self):
+				if len(value) != 1:
+					raise ValueError("expected single byte for assignment")
+				if self.write(int(len(self) + i), value) != 1:
+					raise IndexError("index not writable")
+			else:
+				raise IndexError("index out of range")
+		elif (i >= self.start) and (i < self.end):
+			if len(value) != 1:
+				raise ValueError("expected single byte for assignment")
+			if self.write(int(i), value) != 1:
+				raise IndexError("index not writable")
+		else:
+			raise IndexError("index out of range")
 
 	@classmethod
 	def register(cls):
@@ -1472,20 +1580,6 @@ class BinaryView(object):
 			for i in block:
 				yield i
 
-	def __del__(self):
-		for i in self.notifications.values():
-			i._unregister()
-		core.BNFreeBinaryView(self.handle)
-
-	def __iter__(self):
-		count = ctypes.c_ulonglong(0)
-		funcs = core.BNGetAnalysisFunctionList(self.handle, count)
-		try:
-			for i in range(0, count.value):
-				yield binaryninja.function.Function(self, core.BNNewFunctionReference(funcs[i]))
-		finally:
-			core.BNFreeFunctionList(funcs, count.value)
-
 	@property
 	def parent_view(self):
 		"""View that contains the raw data used by this view (read-only)"""
@@ -1909,81 +2003,6 @@ class BinaryView(object):
 	def new_auto_function_analysis_suppressed(self, suppress):
 		core.BNSetNewAutoFunctionAnalysisSuppressed(self.handle, suppress)
 
-	def __len__(self):
-		return int(core.BNGetViewLength(self.handle))
-
-	def __getitem__(self, i):
-		if isinstance(i, tuple):
-			result = bytes()
-			for s in i:
-				result += self.__getitem__(s)
-			return result
-		elif isinstance(i, slice):
-			if i.step is not None:
-				raise IndexError("step not implemented")
-			i = i.indices(self.end)
-			start = i[0]
-			stop = i[1]
-			if stop <= start:
-				return ""
-			return self.read(start, stop - start)
-		elif i < 0:
-			if i >= -len(self):
-				value = self.read(int(len(self) + i), 1)
-				if len(value) == 0:
-					return IndexError("index not readable")
-				return value
-			raise IndexError("index out of range")
-		elif (i >= self.start) and (i < self.end):
-			value = self.read(int(i), 1)
-			if len(value) == 0:
-				return IndexError("index not readable")
-			return value
-		else:
-			raise IndexError("index out of range")
-
-	def __setitem__(self, i, value):
-		if isinstance(i, slice):
-			if i.step is not None:
-				raise IndexError("step not supported on assignment")
-			i = i.indices(self.end)
-			start = i[0]
-			stop = i[1]
-			if stop < start:
-				stop = start
-			if len(value) != (stop - start):
-				self.remove(start, stop - start)
-				self.insert(start, value)
-			else:
-				self.write(start, value)
-		elif i < 0:
-			if i >= -len(self):
-				if len(value) != 1:
-					raise ValueError("expected single byte for assignment")
-				if self.write(int(len(self) + i), value) != 1:
-					raise IndexError("index not writable")
-			else:
-				raise IndexError("index out of range")
-		elif (i >= self.start) and (i < self.end):
-			if len(value) != 1:
-				raise ValueError("expected single byte for assignment")
-			if self.write(int(i), value) != 1:
-				raise IndexError("index not writable")
-		else:
-			raise IndexError("index out of range")
-
-	def __repr__(self):
-		start = self.start
-		length = len(self)
-		if start != 0:
-			size = "start %#x, len %#x" % (start, length)
-		else:
-			size = "len %#x" % length
-		filename = self._file.filename
-		if len(filename) > 0:
-			return "<BinaryView: '%s', %s>" % (filename, size)
-		return "<BinaryView: %s>" % (size)
-
 	def _init(self, ctxt):
 		try:
 			return self.init()
@@ -5386,15 +5405,18 @@ class BinaryReader(object):
 	def __del__(self):
 		core.BNFreeBinaryReader(self.handle)
 
-	def __eq__(self, value):
-		if not isinstance(value, BinaryReader):
-			return False
-		return ctypes.addressof(self.handle.contents) == ctypes.addressof(value.handle.contents)
+	def __eq__(self, other):
+		if not isinstance(other, self.__class__):
+			return NotImplemented
+		return ctypes.addressof(self.handle.contents) == ctypes.addressof(other.handle.contents)
 
-	def __ne__(self, value):
-		if not isinstance(value, BinaryReader):
-			return True
-		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
+	def __ne__(self, other):
+		if not isinstance(other, self.__class__):
+			return NotImplemented
+		return not (self == other)
+
+	def __hash__(self):
+		return hash(ctypes.addressof(self.handle.contents))
 
 	@property
 	def endianness(self):
@@ -5706,15 +5728,18 @@ class BinaryWriter(object):
 	def __del__(self):
 		core.BNFreeBinaryWriter(self.handle)
 
-	def __eq__(self, value):
-		if not isinstance(value, BinaryWriter):
-			return False
-		return ctypes.addressof(self.handle.contents) == ctypes.addressof(value.handle.contents)
+	def __eq__(self, other):
+		if not isinstance(other, self.__class__):
+			return NotImplemented
+		return ctypes.addressof(self.handle.contents) == ctypes.addressof(other.handle.contents)
 
-	def __ne__(self, value):
-		if not isinstance(value, BinaryWriter):
-			return True
-		return ctypes.addressof(self.handle.contents) != ctypes.addressof(value.handle.contents)
+	def __ne__(self, other):
+		if not isinstance(other, self.__class__):
+			return NotImplemented
+		return not (self == other)
+
+	def __hash__(self):
+		return hash(ctypes.addressof(self.handle.contents))
 
 	@property
 	def endianness(self):
@@ -5920,6 +5945,27 @@ class StructuredDataValue(object):
 		self._address = address
 		self._value = value
 
+	def __str__(self):
+		decode_str = "{}B".format(self._type.width)
+		return ' '.join(["{:02x}".format(x) for x in struct.unpack(decode_str, self._value)])
+
+	def __repr__(self):
+		return "<StructuredDataValue type:{} value:{}>".format(str(self._type), str(self))
+
+	def __int__(self):
+		if self._type.width == 1:
+			code = "B"
+		elif self._type.width == 2:
+			code = "H"
+		elif self._type.width == 4:
+			code = "I"
+		elif self._type.width == 8:
+			code = "Q"
+		else:
+			raise Exception("Could not convert to integer with width {}".format(self._type.width))
+
+		return struct.unpack(code, self._value)[0]
+
 	@property
 	def type(self):
 		return self._type
@@ -5944,27 +5990,6 @@ class StructuredDataValue(object):
 	def str(self):
 		return str(self)
 
-	def __int__(self):
-		if self._type.width == 1:
-			code = "B"
-		elif self._type.width == 2:
-			code = "H"
-		elif self._type.width == 4:
-			code = "I"
-		elif self._type.width == 8:
-			code = "Q"
-		else:
-			raise Exception("Could not convert to integer with width {}".format(self._type.width))
-
-		return struct.unpack(code, self._value)[0]
-
-	def __str__(self):
-		decode_str = "{}B".format(self._type.width)
-		return ' '.join(["{:02x}".format(x) for x in struct.unpack(decode_str, self._value)])
-
-	def __repr__(self):
-		return "<StructuredDataValue type:{} value:{}>".format(str(self._type), str(self))
-
 
 class StructuredDataView(object):
 	"""
@@ -6000,19 +6025,12 @@ class StructuredDataView(object):
 		self._lookup_structure()
 		self._define_members()
 
-	def _lookup_structure(self):
-		s = self._bv.get_type_by_name(self._structure_name)
-		if s is None:
-			raise Exception("Could not find structure with name: {}".format(self._structure_name))
-
-		if s.type_class != TypeClass.StructureTypeClass:
-			raise Exception("{} is not a StructureTypeClass, got: {}".format(self._structure_name, s._type_class))
-
-		self._structure = s.structure
+	def __repr__(self):
+		return "<StructuredDataView type:{} size:{:#x} address:{:#x}>".format(self._structure_name,
+																			  self._structure.width, self._address)
 
-	def _define_members(self):
-		for m in self._structure.members:
-			self._members[m.name] = m
+	def __len__(self):
+		return self._structure.width
 
 	def __getattr__(self, key):
 		m = self._members.get(key, None)
@@ -6056,9 +6074,16 @@ class StructuredDataView(object):
 
 		return rv
 
-	def __repr__(self):
-		return "<StructuredDataView type:{} size:{:#x} address:{:#x}>".format(self._structure_name,
-																			  self._structure.width, self._address)
+	def _lookup_structure(self):
+		s = self._bv.get_type_by_name(self._structure_name)
+		if s is None:
+			raise Exception("Could not find structure with name: {}".format(self._structure_name))
 
-	def __len__(self):
-		return self._structure.width
+		if s.type_class != TypeClass.StructureTypeClass:
+			raise Exception("{} is not a StructureTypeClass, got: {}".format(self._structure_name, s._type_class))
+
+		self._structure = s.structure
+
+	def _define_members(self):
+		for m in self._structure.members:
+			self._members[m.name] = m