Method apply_to_linear_view_object

python/renderlayer.py:315–414

Apply this Render Layer to the lines produced by a LinearViewObject for rendering in Linear View, potentially modifying the lines and their contents. .. note:: If you override this function, you will need to call the ``super()`` \ implementation if you want to use the higher level ``apply_

(
			self,
			obj: 'binaryninja.LinearViewObject',
			prev: Optional['binaryninja.LinearViewObject'],
			next: Optional['binaryninja.LinearViewObject'],
			lines: List['binaryninja.LinearDisassemblyLine']
	)

			node.lines = lines

	def apply_to_linear_view_object(
			self,
			obj: 'binaryninja.LinearViewObject',
			prev: Optional['binaryninja.LinearViewObject'],
			next: Optional['binaryninja.LinearViewObject'],
			lines: List['binaryninja.LinearDisassemblyLine']
	) -> List['binaryninja.LinearDisassemblyLine']:
		"""
		Apply this Render Layer to the lines produced by a LinearViewObject for rendering
		in Linear View, potentially modifying the lines and their contents.

		.. note:: If you override this function, you will need to call the ``super()`` \
		implementation if you want to use the higher level ``apply_to_X_level_il_block`` \
		functionality.

		:param obj: Linear View Object being rendered
		:param prev: Linear View Object located directly above this one
		:param next: Linear View Object located directly below this one
		:param lines: Original lines rendered by the Linear View Object
		:return: Modified list of lines to display in Linear View
		"""
		# Hack: HLIL bodies don't have basic blocks
		if len(lines) > 0 and obj.identifier.name in [
			"HLIL Function Body",
			"HLIL SSA Function Body",
			"Language Representation Function Body"
		]:
			return self.apply_to_high_level_il_body(lines[0].function, lines)

		block_lines = []
		final_lines = []
		last_block = None

		def finish_block():
			nonlocal block_lines
			nonlocal final_lines
			if len(block_lines) > 0:
				if last_block is not None:
					# Convert linear lines to disassembly lines for the apply()
					# and then convert back for linear view
					new_block_lines = []
					disasm_lines = []
					misc_lines = []

					def process_disasm():
						nonlocal disasm_lines

						if len(disasm_lines) > 0:
							disasm_lines = self.apply_to_block(last_block, disasm_lines)
							func = block_lines[0].function
							block = block_lines[0].block
							for block_line in disasm_lines:
								new_block_lines.append(
									LinearDisassemblyLine(
										LinearDisassemblyLineType.CodeDisassemblyLineType,
										func,
										block,
										block_line