Method search

python/binaryview.py:9232–9315

r""" Searches for matches of the specified `pattern` within this BinaryView with an optionally provided address range specified by `start` and `end`. The search pattern can be interpreted in various ways: - specified as a string of hexadecimal digits where whitespace is ignored, and the '?'

(self, pattern: str, start: int = None, end: int = None, raw: bool = False, ignore_case: bool = False, overlap: bool = False, align: int = 1,
		limit: int = None, progress_callback: Optional[ProgressFuncType] = None, match_callback: Optional[DataMatchCallbackType] = None)

			return self.QueueGenerator(t, results)

	def search(self, pattern: str, start: int = None, end: int = None, raw: bool = False, ignore_case: bool = False, overlap: bool = False, align: int = 1,
		limit: int = None, progress_callback: Optional[ProgressFuncType] = None, match_callback: Optional[DataMatchCallbackType] = None) -> QueueGenerator:
		r"""
		Searches for matches of the specified `pattern` within this BinaryView with an optionally provided address range specified by `start` and `end`.
		The search pattern can be interpreted in various ways:

			- specified as a string of hexadecimal digits where whitespace is ignored, and the '?' character acts as a wildcard
			- a regular expression suitable for working with bytes
			- or if the `raw` option is enabled, the pattern is interpreted as a raw string, and any special characters are escaped and interpreted literally

		:param pattern: The pattern to search for.
		:type pattern: :py:class:`str`
		:param start: The address to start the search from. (default: None)
		:type start: :py:class:`int`
		:param end: The address to end the search (inclusive). (default: None)
		:type end: :py:class:`int`
		:param bool raw: Whether to interpret the pattern as a raw string (default: False).
		:param bool ignore_case: Whether to perform case-insensitive matching (default: False).
		:param bool overlap: Whether to allow matches to overlap (default: False).
		:param int align: The alignment of matches, must be a power of 2 (default: 1).
		:param int limit: The maximum number of matches to return (default: None).
		:param callback progress_callback: An optional function to be called with the current progress and total count. \
		This function should return a boolean value that decides whether the search should continue or stop.
		:param callback match_callback: A function that gets called when a match is found. The callback takes two parameters: \
		the address of the match, and the actual DataBuffer that satisfies the search. This function can return a boolean value \
		that decides whether the search should continue or stop.

		:return: A generator object that yields the offset and matched DataBuffer for each match found.
		:rtype: QueueGenerator
		:Example:
			>>> from binaryninja import load
			>>> bv = load('/bin/ls')
			>>> print(bv)
			<BinaryView: '/bin/ls', start 0x100000000, len 0x182f8>
			>>> bytes(list(bv.search("50 ?4"))[0][1]).hex()
			'5004'
			>>> bytes(list(bv.search("[\x20-\x25][\x60-\x67]"))[0][1]).hex()
			'2062'
		"""
		if start is None:
			start = self.start
		if end is None:
			end = self.end
			if end != 0xffffffffffffffff:
				end = end - 1
		if start > end:
			raise ValueError("The start address must be less than or equal to end address!")
		query = {
			"pattern": pattern,
			"start": start,
			"end": end,
			"raw": raw,
			"ignoreCase": ignore_case,
			"overlap": overlap,
			"align": align
		}

		if progress_callback: