Unify higher level api abstraction across py/cpp

Author: CouleeApps

python/renderlayer.py

@@ -325,50 +325,73 @@ def apply_to_linear_view_object(
 		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:
+							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
+									)
+								)
+							disasm_lines = []
+
+					def process_misc():
+						nonlocal misc_lines
+						nonlocal new_block_lines
+
+						if len(misc_lines) > 0:
+							self.apply_to_misc_linear_lines(obj, prev, next, misc_lines)
+							new_block_lines += misc_lines
+							misc_lines = []
+
+					for block_line in block_lines:
+						# Lines in the block get sent to process_disasm, anything else goes
+						# to process_misc so we preserve line information
+						if block_line.type == LinearDisassemblyLineType.CodeDisassemblyLineType:
+							process_misc()
+							disasm_lines.append(block_line.contents)
+						else:
+							process_disasm()
+							misc_lines.append(block_line)
+
+					# At the end, zero or one of these has lines in it
+					process_misc()
+					process_disasm()
+					block_lines = new_block_lines
+				else:
+					self.apply_to_misc_linear_lines(obj, prev, next, block_lines)
+				final_lines += block_lines
+				block_lines = []
+
 		for line in lines:
 			# Assume we've finished a block when the line's block changes
 			if line.block != last_block:
-				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
-						disasm_lines = [block_line.contents for block_line in block_lines]
-						disasm_map = {id(block_line.contents): block_line for block_line in block_lines}
-						self.apply_to_block(last_block, disasm_lines)
-						block_lines = [
-							LinearDisassemblyLine(
-								disasm_map[id(contents)].type if id(contents) in disasm_map else LinearDisassemblyLineType.CodeDisassemblyLineType,
-								block_lines[0].function,
-								block_lines[0].block,
-								contents
-							) for contents in disasm_lines
-						]
-					else:
-						self.apply_to_misc_linear_lines(obj, prev, next, block_lines)
-				last_block = line.block
-				final_lines += block_lines
-				block_lines = []
+				finish_block()
 			block_lines.append(line)
+			last_block = line.block
 
 		# And we've finished a block when we're done with every line
-		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
-				disasm_lines = [line.contents for line in block_lines]
-				disasm_map = {id(line.contents): line for line in block_lines}
-				self.apply_to_block(last_block, disasm_lines)
-				block_lines = [
-					LinearDisassemblyLine(
-						disasm_map[id(contents)].type if id(contents) in disasm_map else LinearDisassemblyLineType.CodeDisassemblyLineType,
-						block_lines[0].function,
-						block_lines[0].block,
-						contents
-					) for contents in disasm_lines
-				]
-			else:
-				self.apply_to_misc_linear_lines(obj, prev, next, block_lines)
-		final_lines += block_lines
+		finish_block()
 		return final_lines
 
 

renderlayer.cpp

@@ -174,82 +174,92 @@ void RenderLayer::ApplyToLinearViewObject(
 	std::vector<LinearDisassemblyLine> finalLines;
 	Ref<BasicBlock> lastBlock;
 
-	for (auto& line: lines)
+	auto finishBlock = [&]()
 	{
-		// Assume we've finished a block when the line's block changes
-		if (line.block != lastBlock)
+		if (!blockLines.empty())
 		{
-			if (!blockLines.empty())
+			if (lastBlock)
 			{
-				if (lastBlock)
+				// Convert linear lines to disassembly lines for the apply()
+				// and then convert back for linear view
+				std::vector<LinearDisassemblyLine> newBlockLines;
+				std::vector<DisassemblyTextLine> disasmLines;
+				std::vector<LinearDisassemblyLine> miscLines;
+
+				auto processDisasm = [&]()
 				{
-					// Convert linear lines to disassembly lines for the apply()
-					// and then convert back for linear view
-					std::vector<DisassemblyTextLine> disasmLines;
-					for (auto& blockLine: blockLines)
+					if (!disasmLines.empty())
 					{
-						disasmLines.push_back(blockLine.contents);
+						ApplyToBlock(lastBlock, disasmLines);
+						Ref<Function> func = blockLines[0].function;
+						Ref<BasicBlock> block = blockLines[0].block;
+						for (auto& blockLine: disasmLines)
+						{
+							LinearDisassemblyLine newLine;
+							newLine.type = CodeDisassemblyLineType;
+							newLine.function = func;
+							newLine.block = block;
+							newLine.contents = blockLine;
+							newBlockLines.push_back(newLine);
+						}
+						disasmLines.clear();
 					}
-					ApplyToBlock(lastBlock, disasmLines);
+				};
 
-					Ref<BasicBlock> block = blockLines[0].block;
-					Ref<Function> func = blockLines[0].function;
-					blockLines.clear();
-					for (auto& blockLine: disasmLines)
+				auto processMisc = [&]()
+				{
+					if (!miscLines.empty())
 					{
-						LinearDisassemblyLine newLine;
-						// todo: losing this information (might not matter)
-						newLine.type = CodeDisassemblyLineType;
-						newLine.block = block;
-						newLine.function = func;
-						newLine.contents = blockLine;
-						blockLines.push_back(newLine);
+						ApplyToMiscLinearLines(obj, prev, next, miscLines);
+						std::move(
+							miscLines.begin(),
+							miscLines.end(),
+							std::back_inserter(newBlockLines)
+						);
+						miscLines.clear();
 					}
-				}
-				else
+				};
+
+				for (auto& blockLine: blockLines)
 				{
-					ApplyToMiscLinearLines(obj, prev, next, blockLines);
+					// Lines in the block get sent to processDisasm, anything else goes
+					// to processMisc so we preserve line information
+					if (blockLine.type == CodeDisassemblyLineType)
+					{
+						processMisc();
+						disasmLines.push_back(blockLine.contents);
+					}
+					else
+					{
+						processDisasm();
+						miscLines.push_back(blockLine);
+					}
 				}
+				// At the end, zero or one of these has lines in it
+				processMisc();
+				processDisasm();
+				blockLines = newBlockLines;
 			}
-			lastBlock = line.block;
-			std::move(blockLines.begin(), blockLines.end(), std::back_inserter(finalLines));
-		}
-		blockLines.push_back(line);
-	}
-	// And we've finished a block when we're done with every line
-	if (!blockLines.empty())
-	{
-		if (lastBlock)
-		{
-			// Convert linear lines to disassembly lines for the apply()
-			// and then convert back for linear view
-			std::vector<DisassemblyTextLine> disasmLines;
-			for (auto& blockLine: blockLines)
-			{
-				disasmLines.push_back(blockLine.contents);
-			}
-			ApplyToBlock(lastBlock, disasmLines);
-
-			Ref<BasicBlock> block = blockLines[0].block;
-			Ref<Function> func = blockLines[0].function;
-			blockLines.clear();
-			for (auto& blockLine: disasmLines)
+			else
 			{
-				LinearDisassemblyLine newLine;
-				// todo: losing this information (might not matter)
-				newLine.type = CodeDisassemblyLineType;
-				newLine.block = block;
-				newLine.function = func;
-				newLine.contents = blockLine;
-				blockLines.push_back(newLine);
+				ApplyToMiscLinearLines(obj, prev, next, blockLines);
 			}
 		}
-		else
+		std::move(blockLines.begin(), blockLines.end(), std::back_inserter(finalLines));
+	};
+
+	for (auto& line: lines)
+	{
+		// Assume we've finished a block when the line's block changes
+		if (line.block != lastBlock)
 		{
-			ApplyToMiscLinearLines(obj, prev, next, blockLines);
+			finishBlock();
 		}
+		blockLines.push_back(line);
+		lastBlock = line.block;
 	}
-	std::move(blockLines.begin(), blockLines.end(), std::back_inserter(finalLines));
+	// And we've finished a block when we're done with every line
+	finishBlock();
 
 	lines = finalLines;
 }