Remove old linear view implementation

6 files changed, 29 insertions, 220 deletions

diff --git a/binaryninjaapi.h b/binaryninjaapi.h
index e48fb33d..8bc209aa 100644
--- a/binaryninjaapi.h
+++ b/binaryninjaapi.h
@@ -1198,13 +1198,6 @@ __attribute__ ((format (printf, 1, 2)))
 		DisassemblyTextLine();
 	};
 
-	struct LinearDisassemblyPosition
-	{
-		Ref<Function> function;
-		Ref<BasicBlock> block;
-		uint64_t address;
-	};
-
 	struct LinearDisassemblyLine
 	{
 		BNLinearDisassemblyLineType type;
@@ -1655,12 +1648,6 @@ __attribute__ ((format (printf, 1, 2)))
 		uint64_t GetPreviousDataBeforeAddress(uint64_t addr);
 		uint64_t GetPreviousDataVariableStartBeforeAddress(uint64_t addr);
 
-		LinearDisassemblyPosition GetLinearDisassemblyPositionForAddress(uint64_t addr, DisassemblySettings* settings);
-		std::vector<LinearDisassemblyLine> GetPreviousLinearDisassemblyLines(LinearDisassemblyPosition& pos,
-			DisassemblySettings* settings);
-		std::vector<LinearDisassemblyLine> GetNextLinearDisassemblyLines(LinearDisassemblyPosition& pos,
-			DisassemblySettings* settings);
-
 		bool ParseTypeString(const std::string& text, QualifiedNameAndType& result, std::string& errors);
 		bool ParseTypeString(const std::string& text, std::map<QualifiedName, Ref<Type>>& result, std::string& errors);
 
diff --git a/binaryninjacore.h b/binaryninjacore.h
index e58144ff..a42fd084 100644
--- a/binaryninjacore.h
+++ b/binaryninjacore.h
@@ -1400,13 +1400,6 @@ extern "C"
 		BNDisassemblyTextLine contents;
 	};
 
-	struct BNLinearDisassemblyPosition
-	{
-		BNFunction* function;
-		BNBasicBlock* block;
-		uint64_t address;
-	};
-
 	struct BNReferenceSource
 	{
 		BNFunction* func;
@@ -2978,15 +2971,6 @@ __attribute__ ((format (printf, 1, 2)))
 	BINARYNINJACOREAPI uint64_t BNGetPreviousDataBeforeAddress(BNBinaryView* view, uint64_t addr);
 	BINARYNINJACOREAPI uint64_t BNGetPreviousDataVariableStartBeforeAddress(BNBinaryView* view, uint64_t addr);
 
-	BINARYNINJACOREAPI BNLinearDisassemblyPosition BNGetLinearDisassemblyPositionForAddress(BNBinaryView* view,
-		uint64_t addr, BNDisassemblySettings* settings);
-	BINARYNINJACOREAPI void BNFreeLinearDisassemblyPosition(BNLinearDisassemblyPosition* pos);
-	BINARYNINJACOREAPI BNLinearDisassemblyLine* BNGetPreviousLinearDisassemblyLines(BNBinaryView* view,
-		BNLinearDisassemblyPosition* pos, BNDisassemblySettings* settings, size_t* count);
-	BINARYNINJACOREAPI BNLinearDisassemblyLine* BNGetNextLinearDisassemblyLines(BNBinaryView* view,
-		BNLinearDisassemblyPosition* pos, BNDisassemblySettings* settings, size_t* count);
-	BINARYNINJACOREAPI void BNFreeLinearDisassemblyLines(BNLinearDisassemblyLine* lines, size_t count);
-
 	BINARYNINJACOREAPI BNLinearViewObject* BNCreateLinearViewDisassemblyByBlock(BNBinaryView* view,
 		BNDisassemblySettings* settings);
 	BINARYNINJACOREAPI BNLinearViewObject* BNNewLinearViewObjectReference(BNLinearViewObject* obj);
@@ -3003,6 +2987,7 @@ __attribute__ ((format (printf, 1, 2)))
 		BNLinearViewObjectIdentifier* id);
 	BINARYNINJACOREAPI BNLinearDisassemblyLine* BNGetLinearViewObjectLines(BNLinearViewObject* obj,
 		BNLinearViewObject* prev, BNLinearViewObject* next, size_t* count);
+	BINARYNINJACOREAPI void BNFreeLinearDisassemblyLines(BNLinearDisassemblyLine* lines, size_t count);
 	BINARYNINJACOREAPI uint64_t BNGetLinearViewObjectStart(BNLinearViewObject* obj);
 	BINARYNINJACOREAPI uint64_t BNGetLinearViewObjectEnd(BNLinearViewObject* obj);
 	BINARYNINJACOREAPI BNLinearViewObjectIdentifier BNGetLinearViewObjectIdentifier(BNLinearViewObject* obj);
diff --git a/binaryview.cpp b/binaryview.cpp
index 32cc688d..30aeeae8 100644
--- a/binaryview.cpp
+++ b/binaryview.cpp
@@ -2446,94 +2446,6 @@ uint64_t BinaryView::GetPreviousDataVariableStartBeforeAddress(uint64_t addr)
 }
 
 
-LinearDisassemblyPosition BinaryView::GetLinearDisassemblyPositionForAddress(uint64_t addr,
-	DisassemblySettings* settings)
-{
-	BNLinearDisassemblyPosition pos = BNGetLinearDisassemblyPositionForAddress(m_object, addr,
-		settings ? settings->GetObject() : nullptr);
-
-	LinearDisassemblyPosition result;
-	result.function = pos.function ? new Function(pos.function) : nullptr;
-	result.block = pos.block ? new BasicBlock(pos.block) : nullptr;
-	result.address = pos.address;
-	return result;
-}
-
-
-vector<LinearDisassemblyLine> BinaryView::GetPreviousLinearDisassemblyLines(LinearDisassemblyPosition& pos,
-	DisassemblySettings* settings)
-{
-	BNLinearDisassemblyPosition linearPos;
-	linearPos.function = pos.function ? BNNewFunctionReference(pos.function->GetObject()) : nullptr;
-	linearPos.block = pos.block ? BNNewBasicBlockReference(pos.block->GetObject()) : nullptr;
-	linearPos.address = pos.address;
-
-	size_t count;
-	BNLinearDisassemblyLine* lines = BNGetPreviousLinearDisassemblyLines(m_object, &linearPos,
-		settings ? settings->GetObject() : nullptr, &count);
-
-	vector<LinearDisassemblyLine> result;
-	result.reserve(count);
-	for (size_t i = 0; i < count; i++)
-	{
-		LinearDisassemblyLine line;
-		line.type = lines[i].type;
-		line.function = lines[i].function ? new Function(BNNewFunctionReference(lines[i].function)) : nullptr;
-		line.block = lines[i].block ? new BasicBlock(BNNewBasicBlockReference(lines[i].block)) : nullptr;
-		line.contents.addr = lines[i].contents.addr;
-		line.contents.instrIndex = lines[i].contents.instrIndex;
-		line.contents.highlight = lines[i].contents.highlight;
-		line.contents.tokens = InstructionTextToken::ConvertInstructionTextTokenList(lines[i].contents.tokens, lines[i].contents.count);
-		line.contents.tags = Tag::ConvertTagList(lines[i].contents.tags, lines[i].contents.tagCount);
-		result.push_back(line);
-	}
-
-	pos.function = linearPos.function ? new Function(linearPos.function) : nullptr;
-	pos.block = linearPos.block ? new BasicBlock(linearPos.block) : nullptr;
-	pos.address = linearPos.address;
-
-	BNFreeLinearDisassemblyLines(lines, count);
-	return result;
-}
-
-
-vector<LinearDisassemblyLine> BinaryView::GetNextLinearDisassemblyLines(LinearDisassemblyPosition& pos,
-	DisassemblySettings* settings)
-{
-	BNLinearDisassemblyPosition linearPos;
-	linearPos.function = pos.function ? BNNewFunctionReference(pos.function->GetObject()) : nullptr;
-	linearPos.block = pos.block ? BNNewBasicBlockReference(pos.block->GetObject()) : nullptr;
-	linearPos.address = pos.address;
-
-	size_t count;
-	BNLinearDisassemblyLine* lines = BNGetNextLinearDisassemblyLines(m_object, &linearPos,
-		settings ? settings->GetObject() : nullptr, &count);
-
-	vector<LinearDisassemblyLine> result;
-	result.reserve(count);
-	for (size_t i = 0; i < count; i++)
-	{
-		LinearDisassemblyLine line;
-		line.type = lines[i].type;
-		line.function = lines[i].function ? new Function(BNNewFunctionReference(lines[i].function)) : nullptr;
-		line.block = lines[i].block ? new BasicBlock(BNNewBasicBlockReference(lines[i].block)) : nullptr;
-		line.contents.addr = lines[i].contents.addr;
-		line.contents.instrIndex = lines[i].contents.instrIndex;
-		line.contents.highlight = lines[i].contents.highlight;
-		line.contents.tokens = InstructionTextToken::ConvertInstructionTextTokenList(lines[i].contents.tokens, lines[i].contents.count);
-		line.contents.tags = Tag::ConvertTagList(lines[i].contents.tags, lines[i].contents.tagCount);
-		result.push_back(line);
-	}
-
-	pos.function = linearPos.function ? new Function(linearPos.function) : nullptr;
-	pos.block = linearPos.block ? new BasicBlock(linearPos.block) : nullptr;
-	pos.address = linearPos.address;
-
-	BNFreeLinearDisassemblyLines(lines, count);
-	return result;
-}
-
-
 bool BinaryView::ParseTypeString(const string& text, QualifiedNameAndType& result, string& errors)
 {
 	BNQualifiedNameAndType nt;
diff --git a/python/binaryview.py b/python/binaryview.py
index e9a8cca8..3d2bf78c 100644
--- a/python/binaryview.py
+++ b/python/binaryview.py
@@ -4414,13 +4414,13 @@ class BinaryView(object):
 
 	def get_linear_disassembly_position_at(self, addr, settings=None):
 		"""
-		``get_linear_disassembly_position_at`` instantiates a :py:class:`LinearDisassemblyPosition <binaryninja.lineardisassembly.LinearDisassemblyPosition>` object for use in
+		``get_linear_disassembly_position_at`` instantiates a :py:class:`LinearViewCursor <binaryninja.lineardisassembly.LinearViewCursor>` object for use in
 		:py:meth:`get_previous_linear_disassembly_lines` or :py:meth:`get_next_linear_disassembly_lines`.
 
 		:param int addr: virtual address of linear disassembly position
 		:param DisassemblySettings settings: an instantiated :py:class:`DisassemblySettings` object, defaults to None which will use default settings
-		:return: An instantiated :py:class:`LinearDisassemblyPosition` object for the provided virtual address
-		:rtype: LinearDisassemblyPosition
+		:return: An instantiated :py:class:`LinearViewCursor` object for the provided virtual address
+		:rtype: LinearViewCursor
 		:Example:
 
 			>>> settings = DisassemblySettings()
@@ -4432,65 +4432,17 @@ class BinaryView(object):
 		"""
 		if settings is not None:
 			settings = settings.handle
-		pos = core.BNGetLinearDisassemblyPositionForAddress(self.handle, addr, settings)
-		func = None
-		block = None
-		if pos.function:
-			func = binaryninja.function.Function(self, pos.function)
-		if pos.block:
-			block = basicblock.BasicBlock(pos.block, self)
-		return lineardisassembly.LinearDisassemblyPosition(func, block, pos.address)
-
-	def _get_linear_disassembly_lines(self, api, pos, settings=None):
-		pos_obj = core.BNLinearDisassemblyPosition()
-		pos_obj.function = None
-		pos_obj.block = None
-		pos_obj.address = pos.address
-		if pos.function is not None:
-			pos_obj.function = core.BNNewFunctionReference(pos.function.handle)
-		if pos.block is not None:
-			pos_obj.block = core.BNNewBasicBlockReference(pos.block.handle)
-
-		if settings is not None:
-			settings = settings.handle
-
-		count = ctypes.c_ulonglong(0)
-		lines = api(self.handle, pos_obj, settings, count)
-
-		result = []
-		for i in range(0, count.value):
-			func = None
-			block = None
-			if lines[i].function:
-				func = binaryninja.function.Function(self, core.BNNewFunctionReference(lines[i].function))
-			if lines[i].block:
-				block = basicblock.BasicBlock(core.BNNewBasicBlockReference(lines[i].block), self)
-			color = highlight.HighlightColor._from_core_struct(lines[i].contents.highlight)
-			addr = lines[i].contents.addr
-			tokens = binaryninja.function.InstructionTextToken.get_instruction_lines(lines[i].contents.tokens, lines[i].contents.count)
-			contents = binaryninja.function.DisassemblyTextLine(tokens, addr, color = color)
-			result.append(lineardisassembly.LinearDisassemblyLine(lines[i].type, func, block, contents))
-
-		func = None
-		block = None
-		if pos_obj.function:
-			func = binaryninja.function.Function(self, pos_obj.function)
-		if pos_obj.block:
-			block = basicblock.BasicBlock(pos_obj.block, self)
-		pos.function = func
-		pos.block = block
-		pos.address = pos_obj.address
-
-		core.BNFreeLinearDisassemblyLines(lines, count.value)
-		return result
+		pos = lineardisassembly.LinearViewCursor(lineardisassembly.LinearViewObject.disassembly_by_block(self, settings))
+		pos.seek_to_address(addr)
+		return pos
 
 	def get_previous_linear_disassembly_lines(self, pos, settings=None):
 		"""
 		``get_previous_linear_disassembly_lines`` retrieves a list of :py:class:`LinearDisassemblyLine` objects for the
-		previous disassembly lines, and updates the LinearDisassemblyPosition passed in. This function can be called
+		previous disassembly lines, and updates the LinearViewCursor passed in. This function can be called
 		repeatedly to get more lines of linear disassembly.
 
-		:param LinearDisassemblyPosition pos: Position to start retrieving linear disassembly lines from
+		:param LinearViewCursor pos: Position to start retrieving linear disassembly lines from
 		:param DisassemblySettings settings: DisassemblySettings display settings for the linear disassembly, defaults to None which will use default settings
 		:return: a list of :py:class:`LinearDisassemblyLine` objects for the previous lines.
 		:Example:
@@ -4502,15 +4454,20 @@ class BinaryView(object):
 			>>> bv.get_previous_linear_disassembly_lines(pos, settings)
 			[<0x10001483: xor     eax, eax  {0x0}>, ... , <0x10001488: >]
 		"""
-		return self._get_linear_disassembly_lines(core.BNGetPreviousLinearDisassemblyLines, pos, settings)
+		result = []
+		while len(result) == 0:
+			if not pos.previous():
+				return result
+			result = pos.lines
+		return result
 
 	def get_next_linear_disassembly_lines(self, pos, settings=None):
 		"""
 		``get_next_linear_disassembly_lines`` retrieves a list of :py:class:`LinearDisassemblyLine` objects for the
-		next disassembly lines, and updates the LinearDisassemblyPosition passed in. This function can be called
+		next disassembly lines, and updates the LinearViewCursor passed in. This function can be called
 		repeatedly to get more lines of linear disassembly.
 
-		:param LinearDisassemblyPosition pos: Position to start retrieving linear disassembly lines from
+		:param LinearViewCursor pos: Position to start retrieving linear disassembly lines from
 		:param DisassemblySettings settings: DisassemblySettings display settings for the linear disassembly, defaults to None which will use default settings
 		:return: a list of :py:class:`LinearDisassemblyLine` objects for the next lines.
 		:Example:
@@ -4523,7 +4480,12 @@ class BinaryView(object):
 			[<0x10001488: push    dword [ebp+0x10 {arg_c}]>, ... , <0x1000149a: >]
 			>>>
 		"""
-		return self._get_linear_disassembly_lines(core.BNGetNextLinearDisassemblyLines, pos, settings)
+		result = []
+		while len(result) == 0:
+			result = pos.lines
+			if not pos.next():
+				return result
+		return result
 
 	def get_linear_disassembly(self, settings=None):
 		"""
@@ -4552,7 +4514,8 @@ class BinaryView(object):
 				self._settings = settings
 
 			def __iter__(self):
-				pos = self._view.get_linear_disassembly_position_at(self._view.start, self.settings)
+				pos = lineardisassembly.LinearViewCursor(lineardisassembly.LinearViewObject.disassembly_by_block(
+					self.view, self.settings))
 				while True:
 					lines = self._view.get_next_linear_disassembly_lines(pos, self.settings)
 					if len(lines) == 0:
diff --git a/python/lineardisassembly.py b/python/lineardisassembly.py
index 24574e48..9a94b08b 100644
--- a/python/lineardisassembly.py
+++ b/python/lineardisassembly.py
@@ -28,46 +28,6 @@ from binaryninja import basicblock
 from binaryninja.enums import LinearViewObjectIdentifierType
 
 
-class LinearDisassemblyPosition(object):
-	"""
-	``class LinearDisassemblyPosition`` is a helper object containing the position of the current Linear Disassembly
-
-	.. note:: This object should not be instantiated directly. Rather call \
-	:py:meth:`get_linear_disassembly_position_at <binaryninja.binaryview.BinaryView.get_linear_disassembly_position_at>` which instantiates this object.
-	"""
-	def __init__(self, func, block, addr):
-		self._function = func
-		self._block = block
-		self._address = addr
-
-	@property
-	def function(self):
-		""" """
-		return self._function
-
-	@function.setter
-	def function(self, value):
-		self._function = value
-
-	@property
-	def block(self):
-		""" """
-		return self._block
-
-	@block.setter
-	def block(self, value):
-		self._block = value
-
-	@property
-	def address(self):
-		""" """
-		return self._address
-
-	@address.setter
-	def address(self, value):
-		self._address = value
-
-
 class LinearDisassemblyLine(object):
 	def __init__(self, line_type, func, block, contents):
 		self.type = line_type
diff --git a/ui/linearview.h b/ui/linearview.h
index f8f85439..b4928785 100644
--- a/ui/linearview.h
+++ b/ui/linearview.h
@@ -19,15 +19,17 @@ struct BINARYNINJAUIAPI LinearViewLine: public BinaryNinja::LinearDisassemblyLin
 	size_t lineIndex;
 };
 
-struct BINARYNINJAUIAPI LinearViewCursorPosition: public BinaryNinja::LinearDisassemblyPosition
+struct BINARYNINJAUIAPI LinearViewCursorPosition
 {
+	FunctionRef function;
+	BasicBlockRef block;
+	uint64_t address;
 	BinaryNinja::Ref<BinaryNinja::LinearViewCursor> cursor;
 	size_t lineIndex;
 	size_t tokenIndex;
 
 	LinearViewCursorPosition();
 	LinearViewCursorPosition(const LinearViewCursorPosition& pos);
-	LinearViewCursorPosition(const BinaryNinja::LinearDisassemblyPosition& pos);
 	LinearViewCursorPosition(const LinearViewLine& line);
 	LinearViewCursorPosition& operator=(const LinearViewCursorPosition& pos);