more updates for the undocumented properties changeset -- specifically revert on LinearDisassemglyLine so third-party plugins that leverage lineardisassemblylines can work again

4 files changed, 182 insertions, 147 deletions

diff --git a/python/binaryview.py b/python/binaryview.py
index a3e1137d..afbf7f39 100644
--- a/python/binaryview.py
+++ b/python/binaryview.py
@@ -103,10 +103,10 @@ class StringReference(object):
 
 	@property
 	def value(self):
-		return binaryninja.pyNativeStr(self.view.read(self.start, self.length))
+		return binaryninja.pyNativeStr(self._view.read(self._start, self._length))
 
 	def __repr__(self):
-		return "<%s: %#x, len %#x>" % (self.type, self.start, self.length)
+		return "<%s: %#x, len %#x>" % (self._type, self._start, self._length)
 
 	@property
 	def type(self):
@@ -155,7 +155,7 @@ class AnalysisCompletionEvent(object):
 
 	:Example:
 		>>> def on_complete(self):
-		...     print("Analysis Complete", self.view)
+		...     print("Analysis Complete", self._view)
 		...
 		>>> evt = AnalysisCompletionEvent(bv, on_complete)
 		>>>
@@ -164,7 +164,7 @@ class AnalysisCompletionEvent(object):
 		self._view = view
 		self.callback = callback
 		self._cb = ctypes.CFUNCTYPE(None, ctypes.c_void_p)(self._notify)
-		self.handle = core.BNAddAnalysisCompletionEvent(self.view.handle, None, self._cb)
+		self.handle = core.BNAddAnalysisCompletionEvent(self._view.handle, None, self._cb)
 		global _pending_analysis_completion_events
 		_pending_analysis_completion_events[id(self)] = self
 
@@ -217,7 +217,7 @@ class ActiveAnalysisInfo(object):
 		self._submit_count = submit_count
 
 	def __repr__(self):
-		return "<ActiveAnalysisInfo %s, analysis_time %d, update_count %d, submit_count %d>" % (self.func, self.analysis_time, self.update_count, self.submit_count)
+		return "<ActiveAnalysisInfo %s, analysis_time %d, update_count %d, submit_count %d>" % (self._func, self._analysis_time, self._update_count, self._submit_count)
 
 	@property
 	def func(self):
@@ -263,7 +263,7 @@ class AnalysisInfo(object):
 		self._active_info = active_info
 
 	def __repr__(self):
-		return "<AnalysisInfo %s, analysis_time %d, active_info %s>" % (self.state, self.analysis_time, self.active_info)
+		return "<AnalysisInfo %s, analysis_time %d, active_info %s>" % (self._state, self._analysis_time, self._active_info)
 
 	@property
 	def state(self):
@@ -300,11 +300,11 @@ class AnalysisProgress(object):
 		self._total = total
 
 	def __str__(self):
-		if self.state == AnalysisState.DisassembleState:
-			return "Disassembling (%d/%d)" % (self.count, self.total)
-		if self.state == AnalysisState.AnalyzeState:
-			return "Analyzing (%d/%d)" % (self.count, self.total)
-		if self.state == AnalysisState.ExtendedAnalyzeState:
+		if self._state == AnalysisState.DisassembleState:
+			return "Disassembling (%d/%d)" % (self._count, self._total)
+		if self._state == AnalysisState.AnalyzeState:
+			return "Analyzing (%d/%d)" % (self._count, self._total)
+		if self._state == AnalysisState.ExtendedAnalyzeState:
 			return "Extended Analysis"
 		return "Idle"
 
@@ -349,23 +349,23 @@ class DataVariable(object):
 	@property
 	def data_refs_from(self):
 		"""data cross references from this data variable (read-only)"""
-		return self.view.get_data_refs_from(self.address, max(1, len(self)))
+		return self._view.get_data_refs_from(self._address, max(1, len(self)))
 
 	@property
 	def data_refs(self):
 		"""data cross references to this data variable (read-only)"""
-		return self.view.get_data_refs(self.address, max(1, len(self)))
+		return self._view.get_data_refs(self._address, max(1, len(self)))
 
 	@property
 	def code_refs(self):
 		"""code references to this data variable (read-only)"""
-		return self.view.get_code_refs(self.address, max(1, len(self)))
+		return self._view.get_code_refs(self._address, max(1, len(self)))
 
 	def __len__(self):
-		return len(self.type)
+		return len(self._type)
 
 	def __repr__(self):
-		return "<var 0x%x: %s>" % (self.address, str(self.type))
+		return "<var 0x%x: %s>" % (self._address, str(self._type))
 
 	@property
 	def address(self):
@@ -426,103 +426,103 @@ class BinaryDataNotificationCallbacks(object):
 		self._cb.typeUndefined = self._cb.typeUndefined.__class__(self._type_undefined)
 
 	def _register(self):
-		core.BNRegisterDataNotification(self.view.handle, self._cb)
+		core.BNRegisterDataNotification(self._view.handle, self._cb)
 
 	def _unregister(self):
-		core.BNUnregisterDataNotification(self.view.handle, self._cb)
+		core.BNUnregisterDataNotification(self._view.handle, self._cb)
 
 	def _data_written(self, ctxt, view, offset, length):
 		try:
-			self.notify.data_written(self.view, offset, length)
+			self._notify.data_written(self._view, offset, length)
 		except OSError:
 			log.log_error(traceback.format_exc())
 
 	def _data_inserted(self, ctxt, view, offset, length):
 		try:
-			self.notify.data_inserted(self.view, offset, length)
+			self._notify.data_inserted(self._view, offset, length)
 		except:
 			log.log_error(traceback.format_exc())
 
 	def _data_removed(self, ctxt, view, offset, length):
 		try:
-			self.notify.data_removed(self.view, offset, length)
+			self._notify.data_removed(self._view, offset, length)
 		except:
 			log.log_error(traceback.format_exc())
 
 	def _function_added(self, ctxt, view, func):
 		try:
-			self.notify.function_added(self.view, binaryninja.function.Function(self.view, core.BNNewFunctionReference(func)))
+			self._notify.function_added(self._view, binaryninja.function.Function(self._view, core.BNNewFunctionReference(func)))
 		except:
 			log.log_error(traceback.format_exc())
 
 	def _function_removed(self, ctxt, view, func):
 		try:
-			self.notify.function_removed(self.view, binaryninja.function.Function(self.view, core.BNNewFunctionReference(func)))
+			self._notify.function_removed(self._view, binaryninja.function.Function(self._view, core.BNNewFunctionReference(func)))
 		except:
 			log.log_error(traceback.format_exc())
 
 	def _function_updated(self, ctxt, view, func):
 		try:
-			self.notify.function_updated(self.view, binaryninja.function.Function(self.view, core.BNNewFunctionReference(func)))
+			self._notify.function_updated(self._view, binaryninja.function.Function(self._view, core.BNNewFunctionReference(func)))
 		except:
 			log.log_error(traceback.format_exc())
 
 	def _function_update_requested(self, ctxt, view, func):
 		try:
-			self.notify.function_update_requested(self.view, binaryninja.function.Function(self.view, core.BNNewFunctionReference(func)))
+			self._notify.function_update_requested(self._view, binaryninja.function.Function(self._view, core.BNNewFunctionReference(func)))
 		except:
 			log.log_error(traceback.format_exc())
 
 	def _data_var_added(self, ctxt, view, var):
 		try:
 			address = var[0].address
-			var_type = types.Type(core.BNNewTypeReference(var[0].type), platform = self.view.platform, confidence = var[0].typeConfidence)
+			var_type = types.Type(core.BNNewTypeReference(var[0].type), platform = self._view.platform, confidence = var[0].typeConfidence)
 			auto_discovered = var[0].autoDiscovered
-			self.notify.data_var_added(self.view, DataVariable(address, var_type, auto_discovered, view))
+			self._notify.data_var_added(self._view, DataVariable(address, var_type, auto_discovered, view))
 		except:
 			log.log_error(traceback.format_exc())
 
 	def _data_var_removed(self, ctxt, view, var):
 		try:
 			address = var[0].address
-			var_type = types.Type(core.BNNewTypeReference(var[0].type), platform = self.view.platform, confidence = var[0].typeConfidence)
+			var_type = types.Type(core.BNNewTypeReference(var[0].type), platform = self._view.platform, confidence = var[0].typeConfidence)
 			auto_discovered = var[0].autoDiscovered
-			self.notify.data_var_removed(self.view, DataVariable(address, var_type, auto_discovered, view))
+			self._notify.data_var_removed(self._view, DataVariable(address, var_type, auto_discovered, view))
 		except:
 			log.log_error(traceback.format_exc())
 
 	def _data_var_updated(self, ctxt, view, var):
 		try:
 			address = var[0].address
-			var_type = types.Type(core.BNNewTypeReference(var[0].type), platform = self.view.platform, confidence = var[0].typeConfidence)
+			var_type = types.Type(core.BNNewTypeReference(var[0].type), platform = self._view.platform, confidence = var[0].typeConfidence)
 			auto_discovered = var[0].autoDiscovered
-			self.notify.data_var_updated(self.view, DataVariable(address, var_type, auto_discovered, view))
+			self._notify.data_var_updated(self._view, DataVariable(address, var_type, auto_discovered, view))
 		except:
 			log.log_error(traceback.format_exc())
 
 	def _string_found(self, ctxt, view, string_type, offset, length):
 		try:
-			self.notify.string_found(self.view, StringType(string_type), offset, length)
+			self._notify.string_found(self._view, StringType(string_type), offset, length)
 		except:
 			log.log_error(traceback.format_exc())
 
 	def _string_removed(self, ctxt, view, string_type, offset, length):
 		try:
-			self.notify.string_removed(self.view, StringType(string_type), offset, length)
+			self._notify.string_removed(self._view, StringType(string_type), offset, length)
 		except:
 			log.log_error(traceback.format_exc())
 
 	def _type_defined(self, ctxt, view, name, type_obj):
 		try:
 			qualified_name = types.QualifiedName._from_core_struct(name[0])
-			self.notify.type_defined(view, qualified_name, types.Type(core.BNNewTypeReference(type_obj), platform = self.view.platform))
+			self._notify.type_defined(view, qualified_name, types.Type(core.BNNewTypeReference(type_obj), platform = self._view.platform))
 		except:
 			log.log_error(traceback.format_exc())
 
 	def _type_undefined(self, ctxt, view, name, type_obj):
 		try:
 			qualified_name = types.QualifiedName._from_core_struct(name[0])
-			self.notify.type_undefined(view, qualified_name, types.Type(core.BNNewTypeReference(type_obj), platform = self.view.platform))
+			self._notify.type_undefined(view, qualified_name, types.Type(core.BNNewTypeReference(type_obj), platform = self._view.platform))
 		except:
 			log.log_error(traceback.format_exc())
 
@@ -608,7 +608,7 @@ class BinaryViewType(with_metaclass(_BinaryViewTypeMetaclass, object)):
 		return core.BNGetBinaryViewTypeLongName(self.handle)
 
 	def __repr__(self):
-		return "<view type: '%s'>" % self.name
+		return "<view type: '%s'>" % self._name
 
 	def create(self, data):
 		view = core.BNCreateBinaryViewOfType(self.handle, data.handle)
@@ -768,7 +768,7 @@ class Segment(object):
 		return core.BNSegmentGetLength(self.handle)
 
 	def __repr__(self):
-		return "<segment: %#x-%#x, %s%s%s>" % (self.start, self.end,
+		return "<segment: %#x-%#x, %s%s%s>" % (self._start, self._end,
 			"r" if self.readable else "-",
 			"w" if self.writable else "-",
 			"x" if self.executable else "-")
@@ -820,7 +820,7 @@ class Section(object):
 
 	@property
 	def end(self):
-		return self.start + len(self)
+		return self._start + len(self)
 
 	def __del__(self):
 		core.BNFreeSection(self.handle)
@@ -842,7 +842,7 @@ class Section(object):
 		return core.BNSectionGetLength(self.handle)
 
 	def __repr__(self):
-		return "<section %s: %#x-%#x>" % (self.name, self.start, self.end)
+		return "<section %s: %#x-%#x>" % (self._name, self._start, self._end)
 
 
 class AddressRange(object):
@@ -852,13 +852,13 @@ class AddressRange(object):
 
 	@property
 	def length(self):
-		return self.end - self.start
+		return self._end - self._start
 
 	def __len__(self):
-		return self.end - self.start
+		return self._end - self._start
 
 	def __repr__(self):
-		return "<%#x-%#x>" % (self.start, self.end)
+		return "<%#x-%#x>" % (self._start, self._end)
 
 	@property
 	def start(self):
@@ -1547,7 +1547,7 @@ class BinaryView(object):
 		elif isinstance(i, slice):
 			if i.step is not None:
 				raise IndexError("step not implemented")
-			i = i.indices(self.end)
+			i = i.indices(self._end)
 			start = i[0]
 			stop = i[1]
 			if stop <= start:
@@ -1560,7 +1560,7 @@ class BinaryView(object):
 					return IndexError("index not readable")
 				return value
 			raise IndexError("index out of range")
-		elif (i >= self.start) and (i < self.end):
+		elif (i >= self._start) and (i < self._end):
 			value = self.read(int(i), 1)
 			if len(value) == 0:
 				return IndexError("index not readable")
@@ -1572,7 +1572,7 @@ class BinaryView(object):
 		if isinstance(i, slice):
 			if i.step is not None:
 				raise IndexError("step not supported on assignment")
-			i = i.indices(self.end)
+			i = i.indices(self._end)
 			start = i[0]
 			stop = i[1]
 			if stop < start:
@@ -1590,7 +1590,7 @@ class BinaryView(object):
 					raise IndexError("index not writable")
 			else:
 				raise IndexError("index out of range")
-		elif (i >= self.start) and (i < self.end):
+		elif (i >= self._start) and (i < self._end):
 			if len(value) != 1:
 				raise ValueError("expected single byte for assignment")
 			if self.write(int(i), value) != 1:
@@ -1599,7 +1599,7 @@ class BinaryView(object):
 			raise IndexError("index out of range")
 
 	def __repr__(self):
-		start = self.start
+		start = self._start
 		length = len(self)
 		if start != 0:
 			size = "start %#x, len %#x" % (start, length)
@@ -3438,7 +3438,7 @@ class BinaryView(object):
 			strings = core.BNGetStrings(self.handle, count)
 		else:
 			if length is None:
-				length = self.end - start
+				length = self._end - start
 			strings = core.BNGetStringsInRange(self.handle, start, length, count)
 		result = []
 		for i in range(0, count.value):
@@ -3495,7 +3495,7 @@ class BinaryView(object):
 		"""
 		if not isinstance(addr, numbers.Integral):
 			raise AttributeError("Input address (" + str(addr) + ") is not a number.")
-		if addr < self.start or addr >= self.end:
+		if addr < self._start or addr >= self._end:
 			return None
 
 		br = BinaryReader(self)
@@ -3604,7 +3604,7 @@ class BinaryView(object):
 			>>>
 		"""
 		next_data_var_start = core.BNGetNextDataVariableStartAfterAddress(self.handle, addr)
-		if next_data_var_start == self.end:
+		if next_data_var_start == self._end:
 			return None
 		var = core.BNDataVariable()
 		if not core.BNGetDataVariableAtAddress(self.handle, next_data_var_start, var):
@@ -3878,9 +3878,9 @@ class BinaryView(object):
 				self._settings = settings
 
 			def __iter__(self):
-				pos = self.view.get_linear_disassembly_position_at(self.view.start, self.settings)
+				pos = self._view.get_linear_disassembly_position_at(self._view.start, self.settings)
 				while True:
-					lines = self.view.get_next_linear_disassembly_lines(pos, self.settings)
+					lines = self._view.get_next_linear_disassembly_lines(pos, self.settings)
 					if len(lines) == 0:
 						break
 					for line in lines:
diff --git a/python/flowgraph.py b/python/flowgraph.py
index 1ef14269..69e3bd69 100644
--- a/python/flowgraph.py
+++ b/python/flowgraph.py
@@ -59,7 +59,6 @@ class FlowGraphNode(object):
 			handle = core.BNCreateFlowGraphNode(graph.handle)
 		self.handle = handle
 		self._graph = graph
-		self.graph = graph
 		if self._graph is None:
 			self._graph = FlowGraph(handle = core.BNGetFlowGraphNodeOwner(self.handle))
 
@@ -198,7 +197,7 @@ class FlowGraphNode(object):
 			branch_type = BranchType(edges[i].type)
 			target = edges[i].target
 			if target:
-				target = FlowGraphNode(self.graph, core.BNNewFlowGraphNodeReference(target))
+				target = FlowGraphNode(self._graph, core.BNNewFlowGraphNodeReference(target))
 			points = []
 			for j in range(0, edges[i].pointCount):
 				points.append((edges[i].points[j].x, edges[i].points[j].y))
@@ -216,7 +215,7 @@ class FlowGraphNode(object):
 			branch_type = BranchType(edges[i].type)
 			target = edges[i].target
 			if target:
-				target = FlowGraphNode(self.graph, core.BNNewFlowGraphNodeReference(target))
+				target = FlowGraphNode(self._graph, core.BNNewFlowGraphNodeReference(target))
 			points = []
 			for j in range(0, edges[i].pointCount):
 				points.append((edges[i].points[j].x, edges[i].points[j].y))
@@ -278,7 +277,7 @@ class FlowGraphNode(object):
 		:param BranchType edge_type: Type of edge to add
 		:param FlowGraphNode target: Target node object
 		"""
-		if not target.is_valid_for_graph(self.graph):
+		if not target.is_valid_for_graph(self._graph):
 			raise ValueError("Target of edge has not been added to the owning graph")
 		core.BNAddFlowGraphNodeOutgoingEdge(self.handle, edge_type, target.handle)
 
diff --git a/python/function.py b/python/function.py
index 4aa9cc39..56ba5f9c 100644
--- a/python/function.py
+++ b/python/function.py
@@ -91,34 +91,34 @@ class RegisterValue(object):
 		self._confidence = confidence
 
 	def __repr__(self):
-		if self.type == RegisterValueType.EntryValue:
+		if self._type == RegisterValueType.EntryValue:
 			return "<entry %s>" % self.reg
-		if self.type == RegisterValueType.ConstantValue:
+		if self._type == RegisterValueType.ConstantValue:
 			return "<const %#x>" % self.value
-		if self.type == RegisterValueType.ConstantPointerValue:
+		if self._type == RegisterValueType.ConstantPointerValue:
 			return "<const ptr %#x>" % self.value
-		if self.type == RegisterValueType.StackFrameOffset:
+		if self._type == RegisterValueType.StackFrameOffset:
 			return "<stack frame offset %#x>" % self.offset
-		if self.type == RegisterValueType.ReturnAddressValue:
+		if self._type == RegisterValueType.ReturnAddressValue:
 			return "<return address>"
-		if self.type == RegisterValueType.ImportedAddressValue:
+		if self._type == RegisterValueType.ImportedAddressValue:
 			return "<imported address from entry %#x>" % self.value
 		return "<undetermined>"
 
 	def _to_api_object(self):
 		result = core.BNRegisterValue()
-		result.state = self.type
+		result.state = self._type
 		result.value = 0
-		if self.type == RegisterValueType.EntryValue:
+		if self._type == RegisterValueType.EntryValue:
 			if self.arch is not None:
 				result.value = self.arch.get_reg_index(self.reg)
 			else:
 				result.value = self.reg
-		elif (self.type == RegisterValueType.ConstantValue) or (self.type == RegisterValueType.ConstantPointerValue):
+		elif (self._type == RegisterValueType.ConstantValue) or (self._type == RegisterValueType.ConstantPointerValue):
 			result.value = self.value
-		elif self.type == RegisterValueType.StackFrameOffset:
+		elif self._type == RegisterValueType.StackFrameOffset:
 			result.value = self.offset
-		elif self.type == RegisterValueType.ImportedAddressValue:
+		elif self._type == RegisterValueType.ImportedAddressValue:
 			result.value = self.value
 		return result
 
@@ -339,25 +339,25 @@ class PossibleValueSet(object):
 				self._values.add(value.valueSet[i])
 
 	def __repr__(self):
-		if self.type == RegisterValueType.EntryValue:
+		if self._type == RegisterValueType.EntryValue:
 			return "<entry %s>" % self.reg
-		if self.type == RegisterValueType.ConstantValue:
+		if self._type == RegisterValueType.ConstantValue:
 			return "<const %#x>" % self.value
-		if self.type == RegisterValueType.ConstantPointerValue:
+		if self._type == RegisterValueType.ConstantPointerValue:
 			return "<const ptr %#x>" % self.value
-		if self.type == RegisterValueType.StackFrameOffset:
+		if self._type == RegisterValueType.StackFrameOffset:
 			return "<stack frame offset %#x>" % self.offset
-		if self.type == RegisterValueType.SignedRangeValue:
+		if self._type == RegisterValueType.SignedRangeValue:
 			return "<signed ranges: %s>" % repr(self.ranges)
-		if self.type == RegisterValueType.UnsignedRangeValue:
+		if self._type == RegisterValueType.UnsignedRangeValue:
 			return "<unsigned ranges: %s>" % repr(self.ranges)
-		if self.type == RegisterValueType.LookupTableValue:
+		if self._type == RegisterValueType.LookupTableValue:
 			return "<table: %s>" % ', '.join([repr(i) for i in self.table])
-		if self.type == RegisterValueType.InSetOfValues:
+		if self._type == RegisterValueType.InSetOfValues:
 			return "<in set(%s)>" % '[{}]'.format(', '.join(hex(i) for i in sorted(self.values)))
-		if self.type == RegisterValueType.NotInSetOfValues:
+		if self._type == RegisterValueType.NotInSetOfValues:
 			return "<not in set(%s)>" % '[{}]'.format(', '.join(hex(i) for i in sorted(self.values)))
-		if self.type == RegisterValueType.ReturnAddressValue:
+		if self._type == RegisterValueType.ReturnAddressValue:
 			return "<return address>"
 		return "<undetermined>"
 
@@ -612,9 +612,9 @@ class Variable(object):
 		return Variable(func, VariableSourceType(var.type), var.index, var.storage, name, var_type)
 
 	def __repr__(self):
-		if self.type is None:
+		if self._type is None:
 			return "<var %s>" % self.name
-		return "<var %s %s%s>" % (self.type.get_string_before_name(), self.name, self.type.get_string_after_name())
+		return "<var %s %s%s>" % (self._type.get_string_before_name(), self.name, self._type.get_string_after_name())
 
 	def __str__(self):
 		return self.name
@@ -2160,12 +2160,12 @@ class RegisterStackInfo(object):
 class IntrinsicInput(object):
 	def __init__(self, type_obj, name=""):
 		self.name = name
-		self.type = type_obj
+		self._type = type_obj
 
 	def __repr__(self):
 		if len(self.name) == 0:
-			return "<input: %s>" % str(self.type)
-		return "<input: %s %s>" % (str(self.type), self.name)
+			return "<input: %s>" % str(self._type)
+		return "<input: %s %s>" % (str(self._type), self.name)
 
 
 class IntrinsicInfo(object):
@@ -2180,12 +2180,12 @@ class IntrinsicInfo(object):
 
 class InstructionBranch(object):
 	def __init__(self, branch_type, target = 0, arch = None):
-		self.type = branch_type
+		self._type = branch_type
 		self.target = target
 		self.arch = arch
 
 	def __repr__(self):
-		branch_type = self.type
+		branch_type = self._type
 		if self.arch is not None:
 			return "<%s: %s@%#x>" % (branch_type.name, self.arch.name, self.target)
 		return "<%s: %#x>" % (branch_type, self.target)
@@ -2249,15 +2249,15 @@ class InstructionTextToken(object):
 	"""
 	def __init__(self, token_type, text, value = 0, size = 0, operand = 0xffffffff,
 		context = InstructionTextTokenContext.NoTokenContext, address = 0, confidence = types.max_confidence, typeNames=[]):
-		self.type = InstructionTextTokenType(token_type)
-		self.text = text
-		self.value = value
-		self.size = size
-		self.operand = operand
-		self.context = InstructionTextTokenContext(context)
-		self.confidence = confidence
-		self.address = address
-		self.typeNames = typeNames
+		self._type = InstructionTextTokenType(token_type)
+		self._text = text
+		self._value = value
+		self._size = size
+		self._operand = operand
+		self._context = InstructionTextTokenContext(context)
+		self._confidence = confidence
+		self._address = address
+		self._typeNames = typeNames
 
 	@classmethod
 	def get_instruction_lines(cls, tokens, count=0):
@@ -2301,10 +2301,91 @@ class InstructionTextToken(object):
 		return result
 
 	def __str__(self):
-		return self.text
+		return self._text
 
 	def __repr__(self):
-		return repr(self.text)
+		return repr(self._text)
+
+	@property
+	def type(self):
+		""" """
+		return self._type
+
+	@type.setter
+	def type(self, value):
+		self._type = value
+
+	@property
+	def text(self):
+		""" """
+		return self._text
+
+	@text.setter
+	def text(self, value):
+		self._text = value
+
+	@property
+	def value(self):
+		""" """
+		return self._value
+
+	@value.setter
+	def value(self, value):
+		self._value = value
+
+	@property
+	def size(self):
+		""" """
+		return self._size
+
+	@size.setter
+	def size(self, value):
+		self._size = value
+
+	@property
+	def operand(self):
+		""" """
+		return self._operand
+
+	@operand.setter
+	def operand(self, value):
+		self._operand = value
+
+	@property
+	def context(self):
+		""" """
+		return self._context
+
+	@context.setter
+	def context(self, value):
+		self._context = value
+
+	@property
+	def confidence(self):
+		""" """
+		return self._confidence
+
+	@confidence.setter
+	def confidence(self, value):
+		self._confidence = value
+
+	@property
+	def address(self):
+		""" """
+		return self._address
+
+	@address.setter
+	def address(self, value):
+		self._address = value
+
+	@property
+	def typeNames(self):
+		""" """
+		return self._typeNames
+
+	@typeNames.setter
+	def typeNames(self, value):
+		self._typeNames = value
 
 
 class DisassemblyTextRenderer(object):
diff --git a/python/lineardisassembly.py b/python/lineardisassembly.py
index 517e64c4..a48ce81b 100644
--- a/python/lineardisassembly.py
+++ b/python/lineardisassembly.py
@@ -61,59 +61,14 @@ class LinearDisassemblyPosition(object):
 
 class LinearDisassemblyLine(object):
 	def __init__(self, line_type, func, block, line_offset, contents):
-		self._type = line_type
-		self._function = func
-		self._block = block
-		self._line_offset = line_offset
-		self._contents = contents
+		self.type = line_type
+		self.function = func
+		self.block = block
+		self.line_offset = line_offset
+		self.contents = contents
 
 	def __str__(self):
-		return str(self._contents)
+		return str(self.contents)
 
 	def __repr__(self):
-		return repr(self._contents)
-
-	@property
-	def type(self):
-		""" """
-		return self._type
-
-	@type.setter
-	def type(self, value):
-		self._type = value
-
-	@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 line_offset(self):
-		""" """
-		return self._line_offset
-
-	@line_offset.setter
-	def line_offset(self, value):
-		self._line_offset = value
-
-	@property
-	def contents(self):
-		""" """
-		return self.contents
-
-	@contents.setter
-	def contents(self, value):
-		self.contents = value
+		return repr(self.contents)
\ No newline at end of file