Method parse_expression

python/binaryview.py:9880–9929

r""" Evaluates a string expression to an integer value. The parser uses the following rules: - Symbols are defined by the lexer as ``[A-Za-z0-9_:<>][A-Za-z0-9_:$\-<>]+`` or anything enclosed in either single or double quotes - Symbols are everything in ``bv.symbols``, unnamed DataVariabl

(self, expression: str, here: int = 0)

		core.BNBinaryViewSetLoadSettings(self.handle, type_name, settings)

	def parse_expression(self, expression: str, here: int = 0) -> int:
		r"""
		Evaluates a string expression to an integer value.

		The parser uses the following rules:

			- Symbols are defined by the lexer as ``[A-Za-z0-9_:<>][A-Za-z0-9_:$\-<>]+`` or anything enclosed in either single or double quotes
			- Symbols are everything in ``bv.symbols``, unnamed DataVariables (i.e. ``data_00005000``), unnamed functions (i.e. ``sub_00005000``), or section names (i.e. ``.text``)
			- Numbers are defaulted to hexadecimal thus `_printf + 10` is equivalent to `printf + 0x10` If decimal numbers required use the decimal prefix.
			- Since numbers and symbols can be ambiguous its recommended that you prefix your numbers with the following:

				- ``0x`` - Hexadecimal
				- ``0n`` - Decimal
				- ``0`` - Octal

			- In the case of an ambiguous number/symbol (one with no prefix) for instance ``12345`` we will first attempt
			  to look up the string as a symbol, if a symbol is found its address is used, otherwise we attempt to convert
			  it to a hexadecimal number.
			- The following operations are valid: ``+, -, \*, /, %, (), &, \|, ^, ~, ==, !=, >, <, >=, <=``

				- Comparison operators return 1 if the condition is true, 0 otherwise.

			- In addition to the above operators there are dereference operators similar to BNIL style IL:

				- ``[<expression>]`` - read the `current address size` at ``<expression>``
				- ``[<expression>].b`` - read the byte at ``<expression>``
				- ``[<expression>].w`` - read the word (2 bytes) at ``<expression>``
				- ``[<expression>].d`` - read the dword (4 bytes) at ``<expression>``
				- ``[<expression>].q`` - read the quadword (8 bytes) at ``<expression>``

			- The ``$here`` (or more succinctly: ``$``) keyword can be used in calculations and is defined as the ``here`` parameter, or the currently selected address
			- The ``$start``/``$end`` keyword represents the address of the first/last bytes in the file respectively
			- Arbitrary magic values (name-value-pairs) can be added to the expression parser via the
			  :py:func:`add_expression_parser_magic_value` API. Notably, the debugger adds all register values into the
			  expression parser so they can be used directly when navigating. The register values can be referenced like
			  `$rbp`, `$x0`, etc. For more details, refer to the related
			  `debugger docs <https://docs.binary.ninja/guide/debugger/index.html#navigating-the-binary>`_.

		:param str expression: Arithmetic expression to be evaluated
		:param int here: (optional) Base address for relative expressions, defaults to zero
		:rtype: int
		"""
		offset = ctypes.c_ulonglong()
		errors = ctypes.c_char_p()
		if not core.BNParseExpression(self.handle, expression, offset, here, errors):
			assert errors.value is not None, "core.BNParseExpression returned errors set to None"
			error_str = errors.value.decode("utf-8")
			core.free_string(errors)
			raise ValueError(error_str)
		return offset.value

	def eval(self, expression: str, here: int = 0) -> int:
		"""