Remove deprecated API functions.

1 files changed, 0 insertions, 343 deletions

diff --git a/python/binaryview.py b/python/binaryview.py
index 9f47005b..aff1e28c 100644
--- a/python/binaryview.py
+++ b/python/binaryview.py
@@ -1284,37 +1284,6 @@ class BinaryViewType(metaclass=_BinaryViewTypeMetaclass):
 		return self.create(data)
 
 	# TODO : Check if we need binary_view_type's at all after these deprecations? (move add_binaryview_finalized_event and add_binaryview_initial_analysis_completion_event to BinaryView?)
-	@classmethod
-	@deprecation.deprecated(deprecated_in="3.5.4378", details="Use :py:func:`binaryninja.load` instead.")
-	def get_view_of_file(
-	    cls, filename: PathType, update_analysis: bool = True, progress_func: Optional[ProgressFuncType] = None
-	) -> Optional['BinaryView']:
-		return BinaryViewType.load(filename, update_analysis, progress_func)
-
-	@classmethod
-	@deprecation.deprecated(deprecated_in="3.5.4378", details="Use :py:func:`binaryninja.load` instead.")
-	def get_view_of_file_with_options(
-	    cls, filename: Union[str, 'os.PathLike'], update_analysis: Optional[bool] = True, progress_func: Optional[ProgressFuncType] = None,
-	    options: Mapping[str, Any] = {}
-	) -> Optional['BinaryView']:
-		return BinaryViewType.load(filename, update_analysis, progress_func, options)
-
-	@classmethod
-	@deprecation.deprecated(deprecated_in="3.5.4378", details="Use :py:func:`binaryninja.load` instead.")
-	def load_raw_view_with_options(
-	    cls, raw_view: Optional['BinaryView'], update_analysis: Optional[bool] = True, progress_func: Optional[ProgressFuncType] = None,
-	    options: Mapping[str, Any] = {}
-	) -> Optional['BinaryView']:
-		if raw_view is None:
-			return None
-		return BinaryViewType.load(raw_view, update_analysis, progress_func, options)
-
-	@classmethod
-	@deprecation.deprecated(deprecated_in="3.5.4378", details="Use :py:func:`binaryninja.load` instead.")
-	def load(
-	    cls, source: Union[str, bytes, bytearray, 'databuffer.DataBuffer', 'os.PathLike', 'BinaryView'], update_analysis: Optional[bool] = True,
-	    progress_func: Optional[ProgressFuncType] = None, options: Mapping[str, Any] = {}) -> Optional['BinaryView']:
-		return BinaryView.load(source, update_analysis, progress_func, options)
 
 	def parse(self, data: 'BinaryView') -> Optional['BinaryView']:
 		view = core.BNParseBinaryViewOfType(self.handle, data.handle)
@@ -1325,13 +1294,6 @@ class BinaryViewType(metaclass=_BinaryViewTypeMetaclass):
 	def is_valid_for_data(self, data: 'BinaryView') -> bool:
 		return core.BNIsBinaryViewTypeValidForData(self.handle, data.handle)
 
-	@deprecation.deprecated(deprecated_in="3.5.4378")
-	def get_default_load_settings_for_data(self, data: 'BinaryView') -> Optional['settings.Settings']:
-		load_settings = core.BNGetBinaryViewDefaultLoadSettingsForData(self.handle, data.handle)
-		if load_settings is None:
-			return None
-		return settings.Settings(handle=load_settings)
-
 	def get_load_settings_for_data(self, data: 'BinaryView') -> Optional['settings.Settings']:
 		view_handle = None
 		if data is not None:
@@ -1432,11 +1394,6 @@ class Segment:
 		x = "x" if self.executable else "-"
 		return f"<segment: {self.start:#x}-{self.end:#x}, {r}{w}{x}>"
 
-	@deprecation.deprecated(deprecated_in="3.4.3997", details="Use :py:attr:`length` instead. Python disallows the length of an object to "
-									">= 0x8000000000000000. See https://bugs.python.org/issue21444.")
-	def __len__(self):
-		return self.length
-
 	@classmethod
 	def serialize(cls, image_base: int, start: int, length: int, data_offset: int=0, data_length: int=0, flags: 'SegmentFlag'=SegmentFlag.SegmentReadable, auto_defined=True, segments: str="[]"):
 		"""
@@ -1546,11 +1503,6 @@ class Section:
 	def __repr__(self):
 		return f"<section {self.name}: {self.start:#x}-{self.end:#x}>"
 
-	@deprecation.deprecated(deprecated_in="3.4.3997", details="Use :py:attr:`length` instead. Python disallows the length of an object to "
-									">= 0x8000000000000000. See https://bugs.python.org/issue21444.")
-	def __len__(self):
-		return self.length
-
 	def __bool__(self):
 		return True
 
@@ -2456,11 +2408,6 @@ class BinaryView:
 			return f"<BinaryView: '{filename}', {size}>"
 		return f"<BinaryView: {size}>"
 
-	@deprecation.deprecated(deprecated_in="3.4.3997", details="Use :py:attr:`length` instead. Python disallows the length of an object to "
-									">= 0x8000000000000000. See https://bugs.python.org/issue21444.")
-	def __len__(self):
-		return int(core.BNGetViewLength(self.handle))
-
 	@property
 	def length(self):
 		return int(core.BNGetViewLength(self.handle))
@@ -6146,45 +6093,6 @@ class BinaryView:
 		core.BNAddTag(self.handle, tag.handle, user)
 		core.BNAddUserDataTag(self.handle, addr, tag.handle)
 
-	@deprecation.deprecated(deprecated_in="3.4.4146", details='Use :py:func:`get_tag_type` instead.')
-	def get_tag_type_by_name(self, name: str) -> Optional['TagType']:
-		tag_type = core.BNGetTagType(self.handle, name)
-		if tag_type is None:
-			return None
-		return TagType(tag_type)
-
-	@deprecation.deprecated(deprecated_in="3.4.4146", details='Use :py:func:`get_tag_type` instead.')
-	def get_tag_type_by_id(self, id: str) -> Optional['TagType']:
-		tag_type = core.BNGetTagTypeById(self.handle, id)
-		if tag_type is None:
-			return None
-		return TagType(tag_type)
-
-	@deprecation.deprecated(deprecated_in="3.4.4146", details='Use :py:func:`add_tag` instead.')
-	def create_user_tag(self, type: 'TagType', data: str) -> 'Tag':
-		return self.create_tag(type, data, True)
-
-	@deprecation.deprecated(deprecated_in="3.4.4146", details='Use :py:func:`add_tag` instead.')
-	def create_auto_tag(self, type: 'TagType', data: str) -> 'Tag':
-		return self.create_tag(type, data, False)
-
-	@deprecation.deprecated(deprecated_in="3.4.4146", details='Use :py:func:`add_tag` instead.')
-	def create_tag(self, tag_type: 'TagType', data: str, user: bool = True) -> 'Tag':
-		if not isinstance(tag_type, TagType):
-			raise ValueError(f"type is not a TagType instead got {type(tag_type)} : {repr(tag_type)}")
-		tag_handle = core.BNCreateTag(tag_type.handle, data)
-		assert tag_handle is not None, "core.BNCreateTag returned None"
-		tag = Tag(tag_handle)
-		core.BNAddTag(self.handle, tag.handle, user)
-		return tag
-
-	@deprecation.deprecated(deprecated_in="3.4.4146")
-	def get_tag(self, id: str) -> Optional['Tag']:
-		tag = core.BNGetTag(self.handle, id)
-		if tag is None:
-			return None
-		return Tag(tag)
-
 	@property
 	def tags(self) -> List[Tuple[int, 'Tag']]:
 		"""
@@ -6225,48 +6133,6 @@ class BinaryView:
 		finally:
 			core.BNFreeTagReferences(tags, count.value)
 
-	@property
-	@deprecation.deprecated(deprecated_in="3.4.4146", details='Use :py:attr:`tags` instead.')
-	def data_tags(self) -> List[Tuple[int, 'Tag']]:
-		return self.tags
-
-	@property
-	@deprecation.deprecated(deprecated_in="3.4.4146", details='Use :py:func:`get_tags` instead.')
-	def auto_data_tags(self) -> List[Tuple[int, 'Tag']]:
-		count = ctypes.c_ulonglong()
-		tags = core.BNGetAutoDataTagReferences(self.handle, count)
-		assert tags is not None, "core.BNGetAutoDataTagReferences return None"
-		result = []
-		try:
-			for i in range(0, count.value):
-				handle = tags[i].tag
-				assert handle is not None, "BNGetAutoDataTagReferences returned handle set to None"
-				tag_ref = core.BNNewTagReference(handle)
-				assert tag_ref is not None, "BNNewTagReference returned None"
-				tag = Tag(tag_ref)
-				result.append((tags[i].addr, tag))
-			return result
-		finally:
-			core.BNFreeTagReferences(tags, count.value)
-
-	@property
-	@deprecation.deprecated(deprecated_in="3.4.4146", details='Use :py:func:`get_tags` instead.')
-	def user_data_tags(self) -> List[Tuple[int, 'Tag']]:
-		count = ctypes.c_ulonglong()
-		refs = core.BNGetUserDataTagReferences(self.handle, count)
-		assert refs is not None, "core.BNGetUserDataTagReferences returned None"
-		result = []
-		try:
-			for i in range(0, count.value):
-				tag_handle = refs[i].tag
-				assert tag_handle is not None, "BNGetUserDataTagReferences returned tag with handle set to None"
-				tag_ref = core.BNNewTagReference(tag_handle)
-				assert tag_ref is not None, "BNNewTagReference returned None"
-				tag = Tag(tag_ref)
-				result.append((refs[i].addr, tag))
-			return result
-		finally:
-			core.BNFreeTagReferences(refs, count.value)
 
 	def get_tags_at(self, addr: int, auto: Optional[bool] = None) -> List['Tag']:
 		"""
@@ -6298,76 +6164,6 @@ class BinaryView:
 		finally:
 			core.BNFreeTagList(tags, count.value)
 
-	@deprecation.deprecated(deprecated_in="3.4.4146", details='Use :py:func:`get_tags_at` instead.')
-	def get_data_tags_at(self, addr: int, auto: Optional[bool] = None) -> List['Tag']:
-		return self.get_tags_at(addr, auto)
-
-	@deprecation.deprecated(deprecated_in="3.4.4146", details='Use :py:func:`get_tags_at` instead.')
-	def get_auto_data_tags_at(self, addr: int) -> List['Tag']:
-		return self.get_tags_at(addr, True)
-
-	@deprecation.deprecated(deprecated_in="3.4.4146", details='Use :py:func:`get_tags_at` instead.')
-	def get_user_data_tags_at(self, addr: int) -> List['Tag']:
-		return self.get_tags_at(addr, False)
-
-	@deprecation.deprecated(deprecated_in="3.4.4146", details='Use :py:func:`get_tags_at` instead.')
-	def get_data_tags_of_type(self, addr: int, tag_type: str, auto: Optional[bool] = None) -> List['Tag']:
-		count = ctypes.c_ulonglong()
-
-		tag_type = self.get_tag_type(tag_type)
-		if tag_type is None:
-			return []
-
-		if auto is None:
-			tags = core.BNGetDataTagsOfType(self.handle, addr, tag_type.handle, count)
-			assert tags is not None, "BNGetDataTagsOfType returned None"
-		elif auto:
-			tags = core.BNGetAutoDataTagsOfType(self.handle, addr, tag_type.handle, count)
-			assert tags is not None, "core.BNGetAutoDataTagsOfType returned None"
-		else:
-			tags = core.BNGetUserDataTagsOfType(self.handle, addr, tag_type.handle, count)
-			assert tags is not None, "core.BNGetUserDataTagsOfType returned None"
-
-		result = []
-		try:
-			for i in range(0, count.value):
-				tag_ref = core.BNNewTagReference(tags[i])
-				assert tag_ref is not None, "BNNewTagReference returned None"
-				result.append(Tag(tag_ref))
-			return result
-		finally:
-			core.BNFreeTagList(tags, count.value)
-
-	@deprecation.deprecated(deprecated_in="3.4.4146", details='Use :py:func:`get_tags_at` instead.')
-	def get_auto_data_tags_of_type(self, addr: int, tag_type: 'TagType') -> List['Tag']:
-		count = ctypes.c_ulonglong()
-		tags = core.BNGetAutoDataTagsOfType(self.handle, addr, tag_type.handle, count)
-		assert tags is not None, "core.BNGetAutoDataTagsOfType returned None"
-		result = []
-		try:
-			for i in range(0, count.value):
-				tag_handle = core.BNNewTagReference(tags[i])
-				assert tag_handle is not None, "core.BNNewTagReference returned None"
-				result.append(Tag(tag_handle))
-			return result
-		finally:
-			core.BNFreeTagList(tags, count.value)
-
-	@deprecation.deprecated(deprecated_in="3.4.4146", details='Use :py:func:`get_tags_at` instead.')
-	def get_user_data_tags_of_type(self, addr: int, tag_type: 'TagType') -> List['Tag']:
-		count = ctypes.c_ulonglong()
-		tags = core.BNGetUserDataTagsOfType(self.handle, addr, tag_type.handle, count)
-		assert tags is not None, "BNGetUserDataTagsOfType returned None"
-		result = []
-		try:
-			for i in range(0, count.value):
-				tag_ref = core.BNNewTagReference(tags[i])
-				assert tag_ref is not None, "BNNewTagReference returned None"
-				result.append(Tag(tag_ref))
-			return result
-		finally:
-			core.BNFreeTagList(tags, count.value)
-
 	def get_tags_in_range(self, address_range: 'variable.AddressRange', auto: Optional[bool] = None) -> List[Tuple[int, 'Tag']]:
 		"""
 		``get_data_tags_in_range`` gets a list of all data :py:class:`Tag` objects in a given range.
@@ -6400,34 +6196,6 @@ class BinaryView:
 		finally:
 			core.BNFreeTagReferences(refs, count.value)
 
-	@deprecation.deprecated(deprecated_in="3.4.4146", details='Use :py:func:`get_tags_in_range` instead.')
-	def get_data_tags_in_range(self, address_range: 'variable.AddressRange', user: Optional[bool] = None) -> List[Tuple[int, 'Tag']]:
-		return self.get_tags_in_range(address_range, user)
-
-	@deprecation.deprecated(deprecated_in="3.4.4146", details='Use :py:func:`get_tags_in_range` instead.')
-	def get_auto_data_tags_in_range(self, address_range: 'variable.AddressRange') -> List[Tuple[int, 'Tag']]:
-		return self.get_tags_in_range(address_range, True)
-
-	@deprecation.deprecated(deprecated_in="3.4.4146", details='Use :py:func:`get_tags_in_range` instead.')
-	def get_user_data_tags_in_range(self, address_range: 'variable.AddressRange') -> List[Tuple[int, 'Tag']]:
-		return self.get_tags_in_range(address_range, False)
-
-	@deprecation.deprecated(deprecated_in="3.4.4146", details='Use :py:func:`add_tag` instead')
-	def add_user_data_tag(self, addr: int, tag: 'Tag'):
-		core.BNAddUserDataTag(self.handle, addr, tag.handle)
-
-	@deprecation.deprecated(deprecated_in="3.4.4146", details='Use :py:func:`add_tag` instead')
-	def create_user_data_tag(self, addr: int, type: 'TagType', data: str, unique: bool = False) -> 'Tag':
-		if unique:
-			tags = self.get_data_tags_at(addr)
-			for tag in tags:
-				if tag.type == type and tag.data == data:
-					return tag
-
-		tag = self.create_tag(type, data, True)
-		core.BNAddUserDataTag(self.handle, addr, tag.handle)
-		return tag
-
 	def remove_user_data_tag(self, addr: int, tag: Tag):
 		"""
 		``remove_user_data_tag`` removes a :py:class:`Tag` object at a data address.
@@ -6452,22 +6220,6 @@ class BinaryView:
 		if tag_type is not None:
 			core.BNRemoveUserDataTagsOfType(self.handle, addr, tag_type.handle)
 
-	@deprecation.deprecated(deprecated_in="3.4.4146", details='Use :py:func:`add_tag` instead')
-	def add_auto_data_tag(self, addr: int, tag: 'Tag'):
-		core.BNAddAutoDataTag(self.handle, addr, tag.handle)
-
-	@deprecation.deprecated(deprecated_in="3.4.4146", details='Use :py:func:`add_tag` instead')
-	def create_auto_data_tag(self, addr: int, type: 'TagType', data: str, unique: bool = False) -> 'Tag':
-		if unique:
-			tags = self.get_data_tags_at(addr)
-			for tag in tags:
-				if tag.type == type and tag.data == data:
-					return tag
-
-		tag = self.create_tag(type, data, False)
-		core.BNAddAutoDataTag(self.handle, addr, tag.handle)
-		return tag
-
 	def remove_auto_data_tag(self, addr: int, tag: 'Tag'):
 		"""
 		``remove_auto_data_tag`` removes a Tag object at a data address.
@@ -10464,13 +10216,6 @@ class StructuredDataValue(object):
 	value: bytes
 	endian: Endianness
 
-	@deprecation.deprecated(deprecated_in="3.4.3997")
-	def __init__(self, t: '_type.Type', addr: int, val: bytes, e: Endianness):
-		self.type = t
-		self.address = addr
-		self.value = val
-		self.endian = e
-
 	def __str__(self):
 		decode_str = "{}B".format(self.type.width)
 		return ' '.join([f"{x:02x}" for x in struct.unpack(decode_str, self.value)])
@@ -10506,94 +10251,6 @@ class StructuredDataValue(object):
 		return int(self)
 
 
-class StructuredDataView(object):
-	"""
-		``class StructuredDataView`` is a convenience class for reading structured binary data.
-
-		StructuredDataView can be instantiated as follows::
-			>>> from binaryninja import *
-			>>> bv = load("/bin/ls")
-			>>> structure = "Elf64_Header"
-			>>> address = bv.start
-			>>> elf = StructuredDataView(bv, structure, address)
-			>>>
-
-		Once instantiated, members can be accessed::
-			>>> print("{:x}".format(elf.machine))
-			003e
-			>>>
-
-		"""
-	@deprecation.deprecated(deprecated_in="3.4.3997", details='Use :py:class:`TypedDataAccessor` or :py:attr:`DataVariable.value` instead.')
-	def __init__(self, bv: 'BinaryView', structure_name: '_types.QualifiedNameType', address: int):
-		self._bv = bv
-		self._structure_name = structure_name
-		self._address = address
-		self._members = OrderedDict()
-		self._endian = bv.endianness
-
-		s = self._bv.get_type_by_name(self._structure_name)
-		if isinstance(s, _types.NamedTypeReferenceType):
-			s = s.target(self._bv)
-		if s is None:
-			raise ValueError(f"Failed to find type: {structure_name}")
-		if not isinstance(s, _types.StructureType):
-			raise ValueError(f"{self._structure_name} is not a StructureTypeClass, got: {type(s)}")
-		self._structure = s
-
-		for m in self._structure.members:
-			self._members[m.name] = m
-
-	def __repr__(self):
-		return f"<StructuredDataView type:{self._structure_name} size:{len(self._structure):#x} address:{self._address:#x}>"
-
-	def __len__(self):
-		return len(self._structure)
-
-	def __getattr__(self, key):
-		m = self._members.get(key, None)
-		if m is None:
-			return self.__getattribute__(key)
-
-		return self[key]
-
-	def __getitem__(self, key: str) -> Optional[StructuredDataValue]:
-		m = self._members.get(key, None)
-		if m is None:
-			return None
-
-		ty = m.type
-		offset = m.offset
-		width = ty.width
-
-		value = self._bv.read(self._address + offset, width)
-		return StructuredDataValue(ty, self._address + offset, value, self._endian)
-
-	def __str__(self):
-		rv = "struct {name} 0x{addr:x} {{\n".format(name=self._structure_name, addr=self._address)
-		for k in self._members:
-			m = self._members[k]
-
-			ty = m.type
-			offset = m.offset
-
-			formatted_offset = "{:=+x}".format(offset)
-			formatted_type = "{:s} {:s}".format(str(ty), k)
-
-			value = self[k]
-			assert value is not None
-			if value.width in (1, 2, 4, 8):
-				formatted_value = str.zfill("{:x}".format(value.int), value.width * 2)
-			else:
-				formatted_value = str(value)
-
-			rv += "\t{:>6s} {:40s} = {:30s}\n".format(formatted_offset, formatted_type, formatted_value)
-
-		rv += "}\n"
-
-		return rv
-
-
 @dataclass
 class TypedDataAccessor:
 	type: '_types.Type'