From 9d761a52c55a052c67d7e895dcf0a5852a35fdca Mon Sep 17 00:00:00 2001 From: KyleMiles Date: Tue, 21 Mar 2023 16:56:09 -0400 Subject: Tags refactor --- python/binaryview.py | 392 +++++++++++++++++++--------------------------- python/function.py | 434 ++++++++++++++++++++++++--------------------------- 2 files changed, 360 insertions(+), 466 deletions(-) (limited to 'python') diff --git a/python/binaryview.py b/python/binaryview.py index 2b202735..f2f08b3b 100644 --- a/python/binaryview.py +++ b/python/binaryview.py @@ -5252,8 +5252,7 @@ class BinaryView: :rtype: TagType :Example: - >>> tt = bv.create_tag_type("Crabby Functions", "🦀") - >>> bv.create_user_data_tag(here, tt, "Get Crabbed") + >>> bv.create_tag_type("Crabby Functions", "🦀") >>> """ tag_handle = core.BNCreateTagType(self.handle) @@ -5264,14 +5263,16 @@ class BinaryView: core.BNAddTagType(self.handle, tag_type.handle) return tag_type - def remove_tag_type(self, tag_type: 'TagType') -> None: + def remove_tag_type(self, tag_type: str): """ ``remove_tag_type`` removes a :py:class:`TagType` and all tags that use it - :param TagType tag_type: The :py:class:`TagType` to remove + :param str tag_type: The name of the tag type to remove :rtype: None """ - core.BNRemoveTagType(self.handle, tag_type.handle) + tag_type = self.get_tag_type(tag_type) + if tag_type is not None: + core.BNRemoveTagType(self.handle, tag_type.handle) @property def tag_types(self) -> Mapping[str, Union['TagType', List['TagType']]]: @@ -5308,63 +5309,74 @@ class BinaryView: def get_tag_type(self, name: str) -> Optional['TagType']: """ - Get a tag type by its name. Shorthand for get_tag_type_by_name() + Get a tag type by its name. :param name: Name of the tag type :return: The relevant tag type, if it exists :rtype: TagType """ - return self.get_tag_type_by_name(name) - def get_tag_type_by_name(self, name: str) -> Optional['TagType']: + if isinstance(name, TagType): + log_warn("Accessing tag types by type is deprecated. Please use the name instead.") + return name + else: + tag_type = core.BNGetTagType(self.handle, name) + if tag_type is not None: + return TagType(tag_type) + else: + log_error(f"Tag type `{name}` does not exist!") + return None + + def add_tag(self, addr: int, tag_type_name: str, data: str, user: bool = True): """ - Get a tag type by its name + ``add_tag`` creates and adds a :py:class:`Tag` object at a data address. - :param name: Name of the tag type - :return: The relevant tag type, if it exists - :rtype: TagType + This API is appropriate for generic data tags. For functions, + consider using :py:func:`~binaryninja.function.Function.add_tag`. + + :param int addr: address at which to add the tag + :param str tag_type_name: The name of the tag type for this Tag + :param str data: additional data for the Tag + :param bool user: Whether or not a user tag + :Example: + + >>> bv.add_tag(here, "Crashes", "Null pointer dereference") + >>> """ + tag_type = self.get_tag_type(tag_type_name) + if tag_type is None: + return + + 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) + core.BNAddUserDataTag(self.handle, addr, tag.handle) + + @deprecation.deprecated(details='get_tag_type_by_name is deprecated; use 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(details='get_tag_type_by_id is deprecated; use get_tag_type instead') def get_tag_type_by_id(self, id: str) -> Optional['TagType']: - """ - Get a tag type by its id - - :param id: Id of the tag type - :return: The relevant tag type, if it exists - :rtype: TagType - """ tag_type = core.BNGetTagTypeById(self.handle, id) if tag_type is None: return None return TagType(tag_type) + @deprecation.deprecated(details='create_user_tag is deprecated; use add_tag instead') def create_user_tag(self, type: 'TagType', data: str) -> 'Tag': return self.create_tag(type, data, True) + @deprecation.deprecated(details='create_auto_tag is deprecated; use add_tag instead') def create_auto_tag(self, type: 'TagType', data: str) -> 'Tag': return self.create_tag(type, data, False) + @deprecation.deprecated(details='create_tag is deprecated; use add_tag instead') def create_tag(self, tag_type: 'TagType', data: str, user: bool = True) -> 'Tag': - """ - ``create_tag`` creates a new :py:class:`Tag` object but does not add it anywhere. - Use :py:func:`create_user_data_tag` to create and add in one step. - - :param TagType tag_type: The :py:class:`TagType` for this Tag - :param str data: additional data for the Tag - :param bool user: Whether or not a user tag - :return: The created Tag - :rtype: Tag - :Example: - - >>> tt = bv.tag_types["Crashes"] - >>> tag = bv.create_tag(tt, "Null pointer dereference", True) - >>> bv.add_user_data_tag(here, 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) @@ -5373,30 +5385,42 @@ class BinaryView: core.BNAddTag(self.handle, tag.handle, user) return tag + @deprecation.deprecated(details='get_tag is deprecated') def get_tag(self, id: str) -> Optional['Tag']: - """ - Get a tag by its id. Note this does not tell you anything about where it is used. - - :param id: tag id - :return: the relevant tag, if it exists - :rtype: Tag - """ tag = core.BNGetTag(self.handle, id) if tag is None: return None return Tag(tag) @property - def data_tags(self) -> List[Tuple[int, 'Tag']]: + def tags(self) -> List[Tuple[int, 'Tag']]: + """ + ``tags`` gets a list of all data :py:class:`Tag` objects in the view. + Tags are returned as a list of (address, :py:class:`Tag`) pairs. + + :type: list(int, Tag) """ - ``data_tags`` gets a list of all data :py:class:`Tag` objects in the view. + return self.get_tags() + + def get_tags(self, auto: Optional[bool] = None) -> List[Tuple[int, 'Tag']]: + """ + ``tags`` gets a list of all data :py:class:`Tag` objects in the view. Tags are returned as a list of (address, :py:class:`Tag`) pairs. :type: list(int, Tag) """ count = ctypes.c_ulonglong() - tags = core.BNGetDataTagReferences(self.handle, count) - assert tags is not None, "core.BNGetDataTagReferences returned None" + + if auto is None: + tags = core.BNGetDataTagReferences(self.handle, count) + assert tags is not None, "core.BNGetDataTagReferences returned None" + elif auto: + tags = core.BNGetAutoDataTagReferences(self.handle, count) + assert tags is not None, "core.BNGetAutoDataTagReferences return None" + else: + tags = core.BNGetUserDataTagReferences(self.handle, count) + assert tags is not None, "core.BNGetUserDataTagReferences returned None" + result = [] try: for i in range(0, count.value): @@ -5408,38 +5432,33 @@ class BinaryView: finally: core.BNFreeTagReferences(tags, count.value) + @deprecation.deprecated(details='data_tags is deprecated; use tags instead') @property - def auto_data_tags(self) -> List[Tuple[int, 'Tag']]: - """ - ``auto_data_tags`` gets a list of all auto-defined data :py:class:`Tag` objects in the view. - Tags are returned as a list of (address, :py:class:`Tag`) pairs. + def data_tags(self) -> List[Tuple[int, 'Tag']]: + return self.tags - :type: list(int, Tag) - """ + @deprecation.deprecated(details='auto_data_tags is deprecated; use get_tags instead') + @property + def auto_data_tags(self) -> List[Tuple[int, 'Tag']]: count = ctypes.c_ulonglong() - refs = core.BNGetAutoDataTagReferences(self.handle, count) - assert refs is not None, "core.BNGetAutoDataTagReferences return None" + 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 = refs[i].tag + 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((refs[i].addr, tag)) + result.append((tags[i].addr, tag)) return result finally: - core.BNFreeTagReferences(refs, count.value) + core.BNFreeTagReferences(tags, count.value) + @deprecation.deprecated(details='user_data_tags is deprecated; use get_tags instead') @property def user_data_tags(self) -> List[Tuple[int, 'Tag']]: - """ - ``user_data_tags`` gets a list of all user data :py:class:`Tag` objects in the view. - Tags are returned as a list of (address, :py:class:`Tag`) pairs. - - :type: list(int, Tag) - """ count = ctypes.c_ulonglong() refs = core.BNGetUserDataTagReferences(self.handle, count) assert refs is not None, "core.BNGetUserDataTagReferences returned None" @@ -5456,17 +5475,26 @@ class BinaryView: finally: core.BNFreeTagReferences(refs, count.value) - def get_data_tags_at(self, addr: int) -> List['Tag']: + def get_tags_at(self, addr: int, auto: Optional[bool] = None) -> List['Tag']: """ - ``get_data_tags_at`` gets a list of all :py:class:`Tag` objects for a data address. + ``get_data_tags_at`` gets a list of :py:class:`Tag` objects for a data address. :param int addr: address to get tags at + :param bool auto: If None, gets all tags, if True, gets auto tags, if False, gets user tags :return: A list of data :py:class:`Tag` objects :rtype: list(Tag) """ count = ctypes.c_ulonglong() - tags = core.BNGetDataTags(self.handle, addr, count) - assert tags is not None, "core.BNGetDataTags returned None" + if auto is None: + tags = core.BNGetDataTags(self.handle, addr, count) + assert tags is not None, "core.BNGetDataTags returned None" + elif auto: + tags = core.BNGetAutoDataTags(self.handle, addr, count) + assert tags is not None, "core.BNGetAutoDataTags returned None" + else: + tags = core.BNGetUserDataTags(self.handle, addr, count) + assert tags is not None, "core.BNGetUserDataTags returned None" + result = [] try: for i in range(0, count.value): @@ -5477,60 +5505,36 @@ class BinaryView: finally: core.BNFreeTagList(tags, count.value) - def get_auto_data_tags_at(self, addr: int) -> List['Tag']: - """ - ``get_auto_data_tags_at`` gets a list of all auto-defined :py:class:`Tag` objects for a data address. + @deprecation.deprecated(details='get_data_tags_at is deprecated; use 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) - :param int addr: address to get tags at - :return: A list of data :py:class:`Tag` objects - :rtype: list(Tag) - """ - count = ctypes.c_ulonglong() - tags = core.BNGetAutoDataTags(self.handle, addr, count) - assert tags is not None, "core.BNGetAutoDataTags 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(details='get_auto_data_tags_at is deprecated; use get_tags_at instead') + def get_auto_data_tags_at(self, addr: int) -> List['Tag']: + return self.get_tags_at(addr, True) + @deprecation.deprecated(details='get_user_data_tags_at is deprecated; use get_tags_at instead') def get_user_data_tags_at(self, addr: int) -> List['Tag']: - """ - ``get_user_data_tags_at`` gets a list of all user :py:class:`Tag` objects for a data address. + return self.get_tags_at(addr, False) - :param int addr: address to get tags at - :return: A list of data :py:class:`Tag` objects - :rtype: list(Tag) - """ + @deprecation.deprecated(details='get_data_tags_of_type is deprecated; use 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() - tags = core.BNGetUserDataTags(self.handle, addr, count) - assert tags is not None, "core.BNGetUserDataTags 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_data_tags_of_type(self, addr: int, tag_type: 'TagType') -> List['Tag']: - """ - ``get_data_tags_of_type`` gets a list of all :py:class:`Tag` objects for a data address of a given type. + 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" - :param int addr: address to get tags at - :param TagType tag_type: :py:class:`TagType` object to match in searching - :return: A list of data :py:class:`Tag` objects - :rtype: list(Tag) - """ - count = ctypes.c_ulonglong() - tags = core.BNGetDataTagsOfType(self.handle, addr, tag_type.handle, count) - assert tags is not None, "BNGetDataTagsOfType returned None" result = [] try: for i in range(0, count.value): @@ -5541,15 +5545,8 @@ class BinaryView: finally: core.BNFreeTagList(tags, count.value) + @deprecation.deprecated(details='get_auto_data_tags_of_type is deprecated; use get_tags_at instead') def get_auto_data_tags_of_type(self, addr: int, tag_type: 'TagType') -> List['Tag']: - """ - ``get_auto_data_tags_of_type`` gets a list of all auto-defined :py:class:`Tag` objects for a data address of a given type. - - :param int addr: address to get tags at - :param TagType tag_type: :py:class:`TagType` object to match in searching - :return: A list of data :py:class:`Tag` objects - :rtype: 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" @@ -5563,15 +5560,8 @@ class BinaryView: finally: core.BNFreeTagList(tags, count.value) + @deprecation.deprecated(details='get_user_data_tags_of_type is deprecated; use get_tags_at instead') def get_user_data_tags_of_type(self, addr: int, tag_type: 'TagType') -> List['Tag']: - """ - ``get_user_data_tags_of_type`` gets a list of all user :py:class:`Tag` objects for a data address of a given type. - - :param int addr: address to get tags at - :param TagType tag_type: :py:class:`TagType` object to match in searching - :return: A list of data :py:class:`Tag` objects - :rtype: list(Tag) - """ count = ctypes.c_ulonglong() tags = core.BNGetUserDataTagsOfType(self.handle, addr, tag_type.handle, count) assert tags is not None, "BNGetUserDataTagsOfType returned None" @@ -5585,18 +5575,27 @@ class BinaryView: finally: core.BNFreeTagList(tags, count.value) - def get_data_tags_in_range(self, address_range: 'variable.AddressRange') -> List[Tuple[int, 'Tag']]: + 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. Range is inclusive at the start, exclusive at the end. :param AddressRange address_range: address range from which to get tags + :param bool auto: If None, gets all tags, if True, gets auto tags, if False, gets auto tags :return: A list of (address, data tag) tuples :rtype: list((int, Tag)) """ count = ctypes.c_ulonglong() - refs = core.BNGetDataTagsInRange(self.handle, address_range.start, address_range.end, count) - assert refs is not None, "BNGetDataTagsInRange returned None" + if auto is None: + refs = core.BNGetDataTagsInRange(self.handle, address_range.start, address_range.end, count) + assert refs is not None, "BNGetDataTagsInRange returned None" + elif auto: + refs = core.BNGetAutoDataTagsInRange(self.handle, address_range.start, address_range.end, count) + assert refs is not None, "BNGetAutoDataTagsInRange returned None" + else: + refs = core.BNGetUserDataTagsInRange(self.handle, address_range.start, address_range.end, count) + assert refs is not None, "BNGetUserDataTagsInRange returned None" + result = [] try: for i in range(0, count.value): @@ -5608,86 +5607,24 @@ class BinaryView: finally: core.BNFreeTagReferences(refs, count.value) - def get_auto_data_tags_in_range(self, address_range: 'variable.AddressRange') -> List[Tuple[int, 'Tag']]: - """ - ``get_auto_data_tags_in_range`` gets a list of all auto-defined data :py:class:`Tag` objects in a given range. - Range is inclusive at the start, exclusive at the end. + @deprecation.deprecated(details='get_data_tags_in_range is deprecated; use 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) - :param AddressRange address_range: address range from which to get tags - :return: A list of (address, data tag) tuples - :rtype: list((int, Tag)) - """ - count = ctypes.c_ulonglong() - refs = core.BNGetAutoDataTagsInRange(self.handle, address_range.start, address_range.end, count) - assert refs is not None, "BNGetAutoDataTagsInRange returned None" - result = [] - try: - for i in range(count.value): - tag_ref = core.BNNewTagReference(refs[i].tag) - 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) + @deprecation.deprecated(details='get_auto_data_tags_in_range is deprecated; use 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(details='get_user_data_tags_in_range is deprecated; use get_tags_in_range instead') def get_user_data_tags_in_range(self, address_range: 'variable.AddressRange') -> List[Tuple[int, 'Tag']]: - """ - ``get_user_data_tags_in_range`` gets a list of all user data :py:class:`Tag` objects in a given range. - Range is inclusive at the start, exclusive at the end. - - :param AddressRange address_range: address range from which to get tags - :return: A list of (address, data tag) tuples - :rtype: list((int, Tag)) - """ - count = ctypes.c_ulonglong() - refs = core.BNGetUserDataTagsInRange(self.handle, address_range.start, address_range.end, count) - assert refs is not None, "BNGetUserDataTagsInRange returned None" - result = [] - try: - for i in range(count.value): - tag_ref = core.BNNewTagReference(refs[i].tag) - 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 add_user_data_tag(self, addr: int, tag: 'Tag') -> None: - """ - ``add_user_data_tag`` adds an already-created :py:class:`Tag` object at a data address. - Since this adds a user tag, it will be added to the current undo buffer. - If you want to create the tag as well, consider using - :py:func:`create_user_data_tag` + return self.get_tags_in_range(address_range, False) - :param int addr: address at which to add the tag - :param Tag tag: :py:class:`Tag` object to be added - :rtype: None - """ + @deprecation.deprecated(details='add_user_data_tag is deprecated; use add_tag instead') + def add_user_data_tag(self, addr: int, tag: 'Tag'): core.BNAddUserDataTag(self.handle, addr, tag.handle) + @deprecation.deprecated(details='create_user_data_tag is deprecated; use add_tag instead') def create_user_data_tag(self, addr: int, type: 'TagType', data: str, unique: bool = False) -> 'Tag': - """ - ``create_user_data_tag`` creates and adds a :py:class:`Tag` object at a data - address. Since this adds a user tag, it will be added to the current - undo buffer. - - This API is appropriate for generic data tags, for functions, - consider using :py:func:`~binaryninja.function.Function.create_user_function_tag` or for - specific addresses inside of functions, use :py:func:`~binaryninja.function.Function.create_user_address_tag`. - - :param int addr: address at which to add the tag - :param TagType type: :py:class:`TagType` for the :py:class:`Tag` that is created - :param str data: additional data for the Tag - :param bool unique: if a tag already exists at this location with this data, don't add another - :return: The created :py:class:`Tag` - :rtype: Tag - :Example: - - >>> tt = bv.tag_types["Crashes"] - >>> bv.create_user_data_tag(here, tt, "String data to associate with this tag") - """ if unique: tags = self.get_data_tags_at(addr) for tag in tags: @@ -5698,7 +5635,7 @@ class BinaryView: core.BNAddUserDataTag(self.handle, addr, tag.handle) return tag - def remove_user_data_tag(self, addr: int, tag: Tag) -> None: + def remove_user_data_tag(self, addr: int, tag: Tag): """ ``remove_user_data_tag`` removes a :py:class:`Tag` object at a data address. Since this removes a user tag, it will be added to the current undo buffer. @@ -5709,40 +5646,25 @@ class BinaryView: """ core.BNRemoveUserDataTag(self.handle, addr, tag.handle) - def remove_user_data_tags_of_type(self, addr: int, tag_type: 'TagType') -> None: + def remove_user_data_tags_of_type(self, addr: int, tag_type: 'str'): """ ``remove_user_data_tags_of_type`` removes all data tags at the given address of the given type. Since this removes user tags, it will be added to the current undo buffer. :param int addr: address at which to add the tags - :param TagType tag_type: :py:class:`TagType` object to match for removing + :param str tag_type: Tag type name to match for removing :rtype: None """ - core.BNRemoveUserDataTagsOfType(self.handle, addr, tag_type.handle) - - def add_auto_data_tag(self, addr: int, tag: 'Tag') -> None: - """ - ``add_auto_data_tag`` adds an already-created :py:class:`Tag` object at a data address. - If you want to create the tag as well, consider using - :py:func:`~create_auto_data_tag` + tag_type = self.get_tag_type(tag_type) + if tag_type is not None: + core.BNRemoveUserDataTagsOfType(self.handle, addr, tag_type.handle) - :param int addr: address at which to add the tag - :param Tag tag: :py:class:`Tag` object to be added - :rtype: None - """ + @deprecation.deprecated(details='add_auto_data_tag is deprecated; use add_tag instead') + def add_auto_data_tag(self, addr: int, tag: 'Tag'): core.BNAddAutoDataTag(self.handle, addr, tag.handle) + @deprecation.deprecated(details='create_auto_data_tag is deprecated; use add_tag instead') def create_auto_data_tag(self, addr: int, type: 'TagType', data: str, unique: bool = False) -> 'Tag': - """ - ``create_auto_data_tag`` creates and adds a :py:class:`Tag` object at a data address. - - :param int addr: address at which to add the tag - :param TagType type: :py:class:`TagType` for the :py:class:`Tag` that is created - :param str data: additional data for the :py:class:`Tag` - :param bool unique: If a tag already exists at this location with this data, don't add another - :return: The created :py:class:`Tag` object - :rtype: Tag - """ if unique: tags = self.get_data_tags_at(addr) for tag in tags: @@ -5753,7 +5675,7 @@ class BinaryView: core.BNAddAutoDataTag(self.handle, addr, tag.handle) return tag - def remove_auto_data_tag(self, addr: int, tag: 'Tag') -> None: + def remove_auto_data_tag(self, addr: int, tag: 'Tag'): """ ``remove_auto_data_tag`` removes a Tag object at a data address. @@ -5763,15 +5685,17 @@ class BinaryView: """ core.BNRemoveAutoDataTag(self.handle, addr, tag.handle) - def remove_auto_data_tags_of_type(self, addr: int, tag_type: 'TagType') -> None: + def remove_auto_data_tags_of_type(self, addr: int, tag_type: 'str'): """ ``remove_auto_data_tags_of_type`` removes all data tags at the given address of the given type. :param int addr: address at which to add the tags - :param TagType tag_type: :py:class:`TagType` object to match for removing + :param str tag_type: Tag type name to match for removing :rtype: None """ - core.BNRemoveAutoDataTagsOfType(self.handle, addr, tag_type.handle) + tag_type = self.get_tag_type(tag_type) + if tag_type is not None: + core.BNRemoveAutoDataTagsOfType(self.handle, addr, tag_type.handle) def can_assemble(self, arch: Optional['architecture.Architecture'] = None) -> bool: """ diff --git a/python/function.py b/python/function.py index 9e3b5344..1a1685f6 100644 --- a/python/function.py +++ b/python/function.py @@ -597,53 +597,199 @@ class Function: finally: core.BNFreeAddressList(addrs) - def create_user_tag(self, type: 'binaryview.TagType', data: str = "") -> 'binaryview.Tag': - """Create a _user_ Tag object""" - return self.create_tag(type, data, True) + @property + def tags(self) -> TagList: + """ + ``tags`` gets a TagList of all Tags in the function (but not "function tags"). + Tags are returned as an iterable indexable object TagList of (arch, address, Tag) tuples. - def create_auto_tag(self, type: 'binaryview.TagType', data: str = "") -> 'binaryview.Tag': - """Create an _auto_ Tag object""" - return self.create_tag(type, data, False) + :rtype: TagList((Architecture, int, Tag)) + """ + return TagList(self) - def create_tag(self, type: 'binaryview.TagType', data: str = "", user: bool = True) -> 'binaryview.Tag': + def get_tags_at(self, addr: int, arch: Optional['architecture.Architecture'] = None, auto: Optional[bool] = None) -> List[Tuple['architecture.Architecture', int, 'binaryview.Tag']]: """ - ``create_tag`` creates a new Tag object but does not add it anywhere. - Use :py:meth:`create_user_address_tag` or - :py:meth:`create_user_function_tag` to create and add in one step. + ``get_tags`` gets a list of Tags (but not function tags). You optionally get tags by address, range, or type, and filter by user tags. + Tags are returned as a list of (arch, address, Tag) tuples. - :param TagType type: The Tag Type for this Tag - :param str data: Additional data for the Tag - :param bool user: Boolean indicating if this is a user tag or not - :return: The created Tag - :rtype: Tag - :Example: + :param int addr: Address to get tags from. + :param bool auto: If None, gets all tags, if True, gets auto tags, if False, gets user tags + :rtype: list((Architecture, int, Tag)) + """ + if arch is None: + assert self.arch is not None, "Can't call get_tags_at for function with no architecture specified" + arch = self.arch + count = ctypes.c_ulonglong() + + if auto is None: + tags = core.BNGetAddressTags(self.handle, arch.handle, addr, count) + assert tags is not None, "core.BNGetAddressTags returned None" + elif auto: + tags = core.BNGetAutoAddressTags(self.handle, arch.handle, addr, count) + assert tags is not None, "core.BNGetAutoAddressTags returned None" + else: + tags = core.BNGetUserAddressTags(self.handle, arch.handle, addr, count) + assert tags is not None, "core.BNGetUserAddressTags returned None" + + result = [] + try: + for i in range(0, count.value): + core_tag = core.BNNewTagReference(tags[i]) + assert core_tag is not None, "core.BNNewTagReference returned None" + result.append(binaryview.Tag(core_tag)) + return result + finally: + core.BNFreeTagList(tags, count.value) - >>> tt = bv.tag_types["Crashes"] - >>> tag = current_function.create_tag(tt, "Null pointer dereference", True) - >>> current_function.add_user_address_tag(here, tag) - >>> + def get_tags_in_range( + self, address_range: 'variable.AddressRange', arch: Optional['architecture.Architecture'] = None, auto: Optional[bool] = None + ) -> List[Tuple['architecture.Architecture', int, 'binaryview.Tag']]: """ - return self.view.create_tag(type, data, user) + ``get_address_tags_in_range`` gets a list of all Tags in the function at a given address. + Range is inclusive at the start, exclusive at the end. - @property - def address_tags(self) -> TagList: + :param AddressRange address_range: Address range from which to get tags + :param Architecture arch: Architecture for the block in which the Tag is located (optional) + :param bool auto: If None, gets all tags, if True, gets auto tags, if False, gets user tags + :return: A list of (arch, address, Tag) tuples + :rtype: list((Architecture, int, Tag)) """ - ``address_tags`` gets a TagList of all address Tags in the function. - Tags are returned as an iterable indexable object TagList of (arch, address, Tag) tuples. + if arch is None: + assert self.arch is not None, "Can't call get_address_tags_in_range for function with no architecture specified" + arch = self.arch + count = ctypes.c_ulonglong() - :rtype: TagList((Architecture, int, Tag)) + if auto is None: + refs = core.BNGetAddressTagsInRange(self.handle, arch.handle, address_range.start, address_range.end, count) + assert refs is not None, "core.BNGetAddressTagsInRange returned None" + elif auto: + refs = core.BNGetAutoAddressTagsInRange(self.handle, arch.handle, address_range.start, address_range.end, count) + assert refs is not None, "core.BNGetAutoAddressTagsInRange returned None" + else: + refs = core.BNGetUserAddressTagsInRange(self.handle, arch.handle, address_range.start, address_range.end, count) + assert refs is not None, "core.BNGetUserAddressTagsInRange returned None" + + try: + result = [] + for i in range(0, count.value): + tag_ref = core.BNNewTagReference(refs[i].tag) + assert tag_ref is not None, "core.BNNewTagReference returned None" + tag = binaryview.Tag(tag_ref) + result.append((arch, refs[i].addr, tag)) + return result + finally: + core.BNFreeTagReferences(refs, count.value) + + def get_function_tags(self, auto: Optional[bool] = None, tag_type: Optional[str] = None) -> List['binaryview.Tag']: """ - return TagList(self) + ``get_function_tags`` gets a list of function Tags for the function. - def get_address_tags_at(self, addr: int, - arch: Optional['architecture.Architecture'] = None) -> List['binaryview.Tag']: + :param bool auto: If None, gets all tags, if True, gets auto tags, if False, gets user tags + :param str tag_type: If None, gets all tags, otherwise only gets tags of the given type + :rtype: list(Tag) + """ + count = ctypes.c_ulonglong() + + tags = [] + if tag_type is not None: + tag_type = self.view.get_tag_type(tag_type) + if tag_type is None: + return [] + + if auto is None: + tags = core.BNGetFunctionTagsOfType(self.handle, tag_type.handle, count) + assert tags is not None, "core.BNGetFunctionTagsOfType returned None" + elif auto: + tags = core.BNGetAutoFunctionTagsOfType(self.handle, tag_type.handle, count) + assert tags is not None, "core.BNGetAutoFunctionTagsOfType returned None" + else: + tags = core.BNGetUserFunctionTagsOfType(self.handle, tag_type.handle, count) + assert tags is not None, "core.BNGetUserFunctionTagsOfType returned None" + else: + if user is None: + tags = core.BNGetFunctionTags(self.handle, count) + assert tags is not None, "core.BNGetFunctionTags returned None" + elif user: + tags = core.BNGetUserFunctionTags(self.handle, count) + assert tags is not None, "core.BNGetUserFunctionTags returned None" + else: + tags = core.BNGetAutoFunctionTags(self.handle, count) + assert tags is not None, "core.BNGetAutoFunctionTags returned None" + + try: + result = [] + for i in range(count.value): + core_tag = core.BNNewTagReference(tags[i]) + assert core_tag is not None, "core.BNNewTagReference returned None" + result.append(binaryview.Tag(core_tag)) + return result + finally: + core.BNFreeTagList(tags, count.value) + + def add_tag( + self, tag_type: str, data: str, addr: Optional[int] = None, auto: bool = False, + arch: Optional['architecture.Architecture'] = None + ): """ - ``get_address_tags_at`` gets a generator of all Tags in the function at a given address. + ``create_user_address_tag`` creates and adds a Tag object at a given + address. Since this adds a user tag, it will be added to the current + undo buffer. To create tags associated with an address that is not + inside of a function, use :py:meth:`add_tag `. - :param int addr: Address to get tags at + :param str tag_type: Tag Type name for the Tag that is created + :param str data: Additional data for the Tag + :param int addr: Address at which to add the tag. If no address is provided, this will create a function tag + :param bool auto: Whether to create the tag as a auto tag (True) or user tag (False) :param Architecture arch: Architecture for the block in which the Tag is added (optional) - :return: A Generator of Tags + :Example: + + >>> current_function.add_tag("Crashes", "Might be a buffer overflow?", here) + >>> + """ + tag_type = self.view.get_tag_type(tag_type) + if tag_type is None: + return + if arch is None: + arch = self.arch + + # Create tag + tag_handle = core.BNCreateTag(tag_type.handle, data) + assert tag_handle is not None, "core.BNCreateTag returned None" + tag = binaryview.Tag(tag_handle) + core.BNAddTag(self.view.handle, tag.handle, auto) + + if auto: + if addr is None: + core.BNAddAutoFunctionTag(self.handle, tag.handle) + else: + core.BNAddAutoAddressTag(self.handle, arch.handle, addr, tag.handle) + else: + if addr is None: + core.BNAddUserFunctionTag(self.handle, tag.handle) + else: + core.BNAddUserAddressTag(self.handle, arch.handle, addr, tag.handle) + + @deprecation.deprecated(details='create_user_tag is deprecated; use add_tag instead') + def create_user_tag(self, type: 'binaryview.TagType', data: str = "") -> 'binaryview.Tag': + return self.create_tag(type, data, True) + + @deprecation.deprecated(details='create_auto_tag is deprecated; use add_tag instead') + def create_auto_tag(self, type: 'binaryview.TagType', data: str = "") -> 'binaryview.Tag': + return self.create_tag(type, data, False) + + @deprecation.deprecated(details='create_tag is deprecated; use add_tag instead') + def create_tag(self, type: 'binaryview.TagType', data: str = "", auto: bool = False) -> 'binaryview.Tag': + return self.view.create_tag(type, data, auto) + + @deprecation.deprecated(details='address_tags is deprecated; use tags instead') + @property + def address_tags(self) -> TagList: + return TagList(self) + + @deprecation.deprecated(details='get_address_tags_at is deprecated; use get_tags_at instead') + def get_address_tags_at(self, addr: int, + arch: Optional['architecture.Architecture'] = None) -> List['binaryview.Tag']: if arch is None: arch = self.arch count = ctypes.c_ulonglong() @@ -659,42 +805,19 @@ class Function: finally: core.BNFreeTagList(tags, count.value) + @deprecation.deprecated(details='add_user_address_tag is deprecated; use add_tag instead') def add_user_address_tag( self, addr: int, tag: 'binaryview.Tag', arch: Optional['architecture.Architecture'] = None ) -> None: - """ - ``add_user_address_tag`` adds an already-created Tag object at a given address. - Since this adds a user tag, it will be added to the current undo buffer. - If you want to create the tag as well, consider using - :meth:`create_user_address_tag ` - - :param int addr: Address at which to add the tag - :param Tag tag: Tag object to be added - :param Architecture arch: Architecture for the block in which the Tag is added (optional) - :rtype: None - """ if arch is None: arch = self.arch core.BNAddUserAddressTag(self.handle, arch.handle, addr, tag.handle) + @deprecation.deprecated(details='create_user_address_tag is deprecated; use add_tag instead') def create_user_address_tag( self, addr: int, tag_type: 'binaryview.TagType', data: str, unique: bool = False, arch: Optional['architecture.Architecture'] = None ) -> 'binaryview.Tag': - """ - ``create_user_address_tag`` creates and adds a Tag object at a given - address. Since this adds a user tag, it will be added to the current - undo buffer. To create tags associated with an address that is not - inside of a function, use :py:meth:`create_user_data_tag `. - - :param int addr: Address at which to add the tag - :param TagType tag_type: Tag Type for the Tag that is created - :param str data: Additional data for the Tag - :param bool unique: If a tag already exists at this location with this data, don't add another - :param Architecture arch: Architecture for the block in which the Tag is added (optional) - :return: The created Tag - :rtype: Tag - """ if not isinstance(tag_type, binaryview.TagType): raise TypeError(f"type is not a TagType instead got {type(tag_type)} : {repr(tag_type)}") if arch is None: @@ -725,38 +848,19 @@ class Function: arch = self.arch core.BNRemoveUserAddressTag(self.handle, arch.handle, addr, tag.handle) + @deprecation.deprecated(details='add_auto_address_tag is deprecated; use add_tag instead') def add_auto_address_tag( self, addr: int, tag: 'binaryview.Tag', arch: Optional['architecture.Architecture'] = None ) -> None: - """ - ``add_auto_address_tag`` adds an already-created Tag object at a given address. - If you want to create the tag as well, consider using - :meth:`create_auto_address_tag ` - - :param int addr: Address at which to add the tag - :param Tag tag: Tag object to be added - :param Architecture arch: Architecture for the block in which the Tag is added (optional) - :rtype: None - """ if arch is None: arch = self.arch core.BNAddAutoAddressTag(self.handle, arch.handle, addr, tag.handle) + @deprecation.deprecated(details='create_auto_address_tag is deprecated; use add_tag instead') def create_auto_address_tag( self, addr: int, type: 'binaryview.TagType', data: str, unique: bool = False, arch: Optional['architecture.Architecture'] = None ) -> 'binaryview.Tag': - """ - ``create_auto_address_tag`` creates and adds a Tag object at a given address. - - :param int addr: Address at which to add the tag - :param TagType type: Tag Type for the Tag that is created - :param str data: Additional data for the Tag - :param bool unique: If a tag already exists at this location with this data, don't add another - :param Architecture arch: Architecture for the block in which the Tag is added (optional) - :return: The created Tag - :rtype: Tag - """ if arch is None: arch = self.arch if unique: @@ -769,13 +873,9 @@ class Function: core.BNAddAutoAddressTag(self.handle, arch.handle, addr, tag.handle) return tag + @deprecation.deprecated(details='function_tags is deprecated; use get_function_tags instead') @property def function_tags(self) -> List['binaryview.Tag']: - """ - ``function_tags`` gets a list of all function Tags for the function. - - :rtype: List(Tag) - """ count = ctypes.c_ulonglong() tags = core.BNGetFunctionTags(self.handle, count) assert tags is not None, "core.BNGetFunctionTags returned None" @@ -789,29 +889,12 @@ class Function: finally: core.BNFreeTagList(tags, count.value) + @deprecation.deprecated(details='add_user_function_tag is deprecated; use add_tag instead') def add_user_function_tag(self, tag: 'binaryview.Tag') -> None: - """ - ``add_user_function_tag`` adds an already-created Tag object as a function tag. - Since this adds a user tag, it will be added to the current undo buffer. - If you want to create the tag as well, consider using - :meth:`create_user_function_tag ` - - :param Tag tag: Tag object to be added - :rtype: None - """ core.BNAddUserFunctionTag(self.handle, tag.handle) + @deprecation.deprecated(details='create_user_function_tag is deprecated; use add_tag instead') def create_user_function_tag(self, type: 'binaryview.TagType', data: str, unique: bool = False) -> 'binaryview.Tag': - """ - ``add_user_function_tag`` creates and adds a Tag object as a function tag. - Since this adds a user tag, it will be added to the current undo buffer. - - :param TagType type: Tag Type for the Tag that is created - :param str data: Additional data for the Tag - :param bool unique: If a tag already exists with this data, don't add another - :return: The created Tag - :rtype: Tag - """ if unique: for tag in self.function_tags: if tag.type == type and tag.data == data: @@ -831,27 +914,12 @@ class Function: """ core.BNRemoveUserFunctionTag(self.handle, tag.handle) + @deprecation.deprecated(details='add_auto_function_tag is deprecated; use add_tag instead') def add_auto_function_tag(self, tag: 'binaryview.Tag') -> None: - """ - ``add_auto_function_tag`` adds an already-created Tag object as a function tag. - If you want to create the tag as well, consider using - :meth:`create_auto_function_tag ` - - :param Tag tag: Tag object to be added - :rtype: None - """ core.BNAddAutoFunctionTag(self.handle, tag.handle) + @deprecation.deprecated(details='create_auto_function_tag is deprecated; use add_tag instead') def create_auto_function_tag(self, type: 'binaryview.TagType', data: str, unique: bool = False) -> 'binaryview.Tag': - """ - ``create_auto_function_tag`` creates and adds a Tag object as a function tag. - - :param TagType type: Tag Type for the Tag that is created - :param str data: Additional data for the Tag - :param bool unique: If a tag already exists with this data, don't add another - :return: The created Tag - :rtype: Tag - """ if unique: for tag in self.function_tags: if tag.type == type and tag.data == data: @@ -861,14 +929,9 @@ class Function: core.BNAddAutoFunctionTag(self.handle, tag.handle) return tag + @deprecation.deprecated(details='auto_address_tags is deprecated; use tags instead') @property def auto_address_tags(self) -> List[Tuple['architecture.Architecture', int, 'binaryview.Tag']]: - """ - ``auto_address_tags`` gets a list of all auto-defined address Tags in the function. - Tags are returned as a list of (arch, address, Tag) tuples. - - :rtype: list((Architecture, int, Tag)) - """ count = ctypes.c_ulonglong() tags = core.BNGetAutoAddressTagReferences(self.handle, count) assert tags is not None, "core.BNGetAutoAddressTagReferences returned None" @@ -884,14 +947,9 @@ class Function: finally: core.BNFreeTagReferences(tags, count.value) + @deprecation.deprecated(details='user_address_tags is deprecated; use tags instead') @property def user_address_tags(self): - """ - ``user_address_tags`` gets a list of all user address Tags in the function. - Tags are returned as a list of (arch, address, Tag) tuples. - - :rtype: list((Architecture, int, Tag)) - """ count = ctypes.c_ulonglong() tags = core.BNGetUserAddressTagReferences(self.handle, count) assert tags is not None, "core.BNGetUserAddressTagReferences returned" @@ -907,15 +965,8 @@ class Function: finally: core.BNFreeTagReferences(tags, count.value) + @deprecation.deprecated(details='get_auto_address_tags_at is deprecated; use get_tags_at instead') def get_auto_address_tags_at(self, addr, arch=None): - """ - ``get_auto_address_tags_at`` gets a list of all auto-defined Tags in the function at a given address. - - :param int addr: Address to get tags at - :param Architecture arch: Architecture for the block in which the Tag is located (optional) - :return: A list of Tags - :rtype: list(Tag) - """ if arch is None: assert self.arch is not None, "Can't call get_auto_address_tags_at for function with no architecture specified" arch = self.arch @@ -932,15 +983,8 @@ class Function: finally: core.BNFreeTagList(tags, count.value) + @deprecation.deprecated(details='get_user_address_tags_at is deprecated; use get_tags_at instead') def get_user_address_tags_at(self, addr, arch=None): - """ - ``get_user_address_tags_at`` gets a list of all user Tags in the function at a given address. - - :param int addr: Address to get tags at - :param Architecture arch: Architecture for the block in which the Tag is located (optional) - :return: A list of Tags - :rtype: list(Tag) - """ if arch is None: assert self.arch is not None, "Can't call get_user_address_tags_at for function with no architecture specified" arch = self.arch @@ -957,16 +1001,8 @@ class Function: finally: core.BNFreeTagList(tags, count.value) + @deprecation.deprecated(details='get_address_tags_of_type is deprecated; use get_tags_at instead') def get_address_tags_of_type(self, addr: int, tag_type: 'binaryview.TagType', arch=None): - """ - ``get_address_tags_of_type`` gets a list of all Tags in the function at a given address with a given type. - - :param int addr: Address to get tags at - :param TagType tag_type: TagType object to match in searching - :param Architecture arch: Architecture for the block in which the Tags are located (optional) - :return: A list of data Tags - :rtype: list(Tag) - """ if arch is None: assert self.arch is not None, "Can't call get_address_tags_of_type for function with no architecture specified" arch = self.arch @@ -983,18 +1019,10 @@ class Function: finally: core.BNFreeTagList(tags, count.value) + @deprecation.deprecated(details='get_auto_address_tags_of_type is deprecated; use get_tags_at instead') def get_auto_address_tags_of_type( self, addr: int, tag_type: 'binaryview.TagType', arch: Optional['architecture.Architecture'] = None ): - """ - ``get_auto_address_tags_of_type`` gets a list of all auto-defined Tags in the function at a given address with a given type. - - :param int addr: Address to get tags at - :param TagType tag_type: TagType object to match in searching - :param Architecture arch: Architecture for the block in which the Tags are located (optional) - :return: A list of data Tags - :rtype: list(Tag) - """ if arch is None: assert self.arch is not None, "Can't call get_auto_address_tags_of_type for function with no architecture specified" arch = self.arch @@ -1011,18 +1039,10 @@ class Function: finally: core.BNFreeTagList(tags, count.value) + @deprecation.deprecated(details='get_user_address_tags_of_type is deprecated; use get_tags_at instead') def get_user_address_tags_of_type( self, addr: int, tag_type: 'binaryview.TagType', arch: Optional['architecture.Architecture'] = None ): - """ - ``get_user_address_tags_of_type`` gets a list of all user Tags in the function at a given address with a given type. - - :param int addr: Address to get tags at - :param TagType tag_type: TagType object to match in searching - :param Architecture arch: Architecture for the block in which the Tags are located (optional) - :return: A list of data Tags - :rtype: list(Tag) - """ if arch is None: assert self.arch is not None, "Can't get_user_address_tags_of_type for function with no architecture specified" arch = self.arch @@ -1039,18 +1059,10 @@ class Function: finally: core.BNFreeTagList(tags, count.value) + @deprecation.deprecated(details='get_address_tags_in_range is deprecated; use get_tags_in_range instead') def get_address_tags_in_range( self, address_range: 'variable.AddressRange', arch: Optional['architecture.Architecture'] = None ) -> List[Tuple['architecture.Architecture', int, 'binaryview.Tag']]: - """ - ``get_address_tags_in_range`` gets a list of all Tags in the function at a given address. - Range is inclusive at the start, exclusive at the end. - - :param AddressRange address_range: Address range from which to get tags - :param Architecture arch: Architecture for the block in which the Tag is located (optional) - :return: A list of (arch, address, Tag) tuples - :rtype: list((Architecture, int, Tag)) - """ if arch is None: assert self.arch is not None, "Can't call get_address_tags_in_range for function with no architecture specified" arch = self.arch @@ -1068,18 +1080,10 @@ class Function: finally: core.BNFreeTagReferences(refs, count.value) + @deprecation.deprecated(details='get_auto_address_tags_in_range is deprecated; use get_tags_in_range instead') def get_auto_address_tags_in_range( self, address_range: 'variable.AddressRange', arch: Optional['architecture.Architecture'] = None ) -> List[Tuple['architecture.Architecture', int, 'binaryview.Tag']]: - """ - ``get_auto_address_tags_in_range`` gets a list of all auto-defined Tags in the function at a given address. - Range is inclusive at the start, exclusive at the end. - - :param AddressRange address_range: Address range from which to get tags - :param Architecture arch: Architecture for the block in which the Tag is located (optional) - :return: A list of (arch, address, Tag) tuples - :rtype: list((Architecture, int, Tag)) - """ if arch is None: assert self.arch is not None, "Can't call get_auto_address_tags_in_range for function with no architecture specified" arch = self.arch @@ -1097,18 +1101,10 @@ class Function: finally: core.BNFreeTagReferences(refs, count.value) + @deprecation.deprecated(details='get_user_address_tags_in_range is deprecated; use get_tags_in_range instead') def get_user_address_tags_in_range( self, address_range: 'variable.AddressRange', arch: Optional['architecture.Architecture'] = None ) -> List[Tuple['architecture.Architecture', int, 'binaryview.Tag']]: - """ - ``get_user_address_tags_in_range`` gets a list of all user Tags in the function at a given address. - Range is inclusive at the start, exclusive at the end. - - :param AddressRange address_range: Address range from which to get tags - :param Architecture arch: Architecture for the block in which the Tag is located (optional) - :return: A list of (arch, address, Tag) tuples - :rtype: list((Architecture, int, Tag)) - """ if arch is None: assert self.arch is not None, "Can't call get_user_address_tags_in_range for function with no architecture specified" arch = self.arch @@ -1168,13 +1164,9 @@ class Function: arch = self.arch core.BNRemoveAutoAddressTagsOfType(self.handle, arch.handle, addr, tag_type.handle) + @deprecation.deprecated(details='auto_function_tags is deprecated; use get_function_tags instead') @property def auto_function_tags(self): - """ - ``auto_function_tags`` gets a list of all auto-defined function Tags for the function. - - :rtype: list(Tag) - """ count = ctypes.c_ulonglong() tags = core.BNGetAutoFunctionTags(self.handle, count) assert tags is not None, "core.BNGetAutoFunctionTags returned None" @@ -1186,13 +1178,9 @@ class Function: core.BNFreeTagList(tags, count.value) return result + @deprecation.deprecated(details='user_function_tags is deprecated; use get_function_tags instead') @property def user_function_tags(self): - """ - ``user_function_tags`` gets a list of all user function Tags for the function. - - :rtype: list(Tag) - """ count = ctypes.c_ulonglong() tags = core.BNGetUserFunctionTags(self.handle, count) assert tags is not None, "core.BNGetUserFunctionTags returned None" @@ -1204,14 +1192,8 @@ class Function: core.BNFreeTagList(tags, count.value) return result + @deprecation.deprecated(details='get_function_tags_of_type is deprecated; use get_function_tags instead') def get_function_tags_of_type(self, tag_type): - """ - ``get_function_tags_of_type`` gets a list of all function Tags with a given type. - - :param TagType tag_type: TagType object to match in searching - :return: A list of data Tags - :rtype: list(Tag) - """ count = ctypes.c_ulonglong() tags = core.BNGetFunctionTagsOfType(self.handle, tag_type.handle, count) assert tags is not None, "core.BNGetFunctionTagsOfType returned None" @@ -1223,14 +1205,8 @@ class Function: core.BNFreeTagList(tags, count.value) return result + @deprecation.deprecated(details='get_auto_function_tags_of_type is deprecated; use get_function_tags instead') def get_auto_function_tags_of_type(self, tag_type): - """ - ``get_auto_function_tags_of_type`` gets a list of all auto-defined function Tags with a given type. - - :param TagType tag_type: TagType object to match in searching - :return: A list of data Tags - :rtype: list(Tag) - """ count = ctypes.c_ulonglong() tags = core.BNGetAutoFunctionTagsOfType(self.handle, tag_type.handle, count) assert tags is not None, "core.BNGetAutoFunctionTagsOfType returned None" @@ -1242,14 +1218,8 @@ class Function: core.BNFreeTagList(tags, count.value) return result + @deprecation.deprecated(details='get_user_function_tags_of_type is deprecated; use get_function_tags instead') def get_user_function_tags_of_type(self, tag_type): - """ - ``get_user_function_tags_of_type`` gets a list of all user function Tags with a given type. - - :param TagType tag_type: TagType object to match in searching - :return: A list of data Tags - :rtype: list(Tag) - """ count = ctypes.c_ulonglong() tags = core.BNGetUserFunctionTagsOfType(self.handle, tag_type.handle, count) assert tags is not None, "core.BNGetUserFunctionTagsOfType returned None" -- cgit v1.3.1