diff --git a/Ghidra/Features/Base/src/main/java/ghidra/program/database/ProgramBuilder.java b/Ghidra/Features/Base/src/main/java/ghidra/program/database/ProgramBuilder.java
index 664fb394b4..062a0eb377 100644
--- a/Ghidra/Features/Base/src/main/java/ghidra/program/database/ProgramBuilder.java
+++ b/Ghidra/Features/Base/src/main/java/ghidra/program/database/ProgramBuilder.java
@@ -151,9 +151,13 @@ public class ProgramBuilder {
 		AutoAnalysisManager mgr = AutoAnalysisManager.getAnalysisManager(program);
 
 		startTransaction();
-		mgr.reAnalyzeAll(program.getMemory().getLoadedAndInitializedAddressSet());
-		mgr.startAnalysis(TaskMonitor.DUMMY, false);
-		endTransaction();
+		try {
+			mgr.reAnalyzeAll(program.getMemory().getLoadedAndInitializedAddressSet());
+			mgr.startAnalysis(TaskMonitor.DUMMY, false);
+		}
+		finally {
+			endTransaction();
+		}
 
 		PluginTool analysisTool = mgr.getAnalysisTool();
 		if (analysisTool != null) {
@@ -334,39 +338,45 @@ public class ProgramBuilder {
 			byte initialValue) {
 
 		startTransaction();
-		Address startAddress = addr(address);
-		Memory memory = program.getMemory();
-		MemoryBlock block = null;
 		try {
-			block = memory.createInitializedBlock(name, startAddress, size, initialValue,
-				TaskMonitor.DUMMY, false);
-			block.setComment(comment);
+			Address startAddress = addr(address);
+			Memory memory = program.getMemory();
+			try {
+				MemoryBlock block = memory.createInitializedBlock(name, startAddress, size,
+					initialValue, TaskMonitor.DUMMY, false);
+				block.setComment(comment);
+				return block;
+			}
+			catch (CancelledException e) {
+				// can't happen
+				throw new AssertException(e);
+			}
+			catch (Exception e) {
+				e.printStackTrace();
+				throw new RuntimeException("Exception building memory", e);
+			}
 		}
-		catch (CancelledException e) {
-			// can't happen
+		finally {
+			endTransaction();
 		}
-		catch (Exception e) {
-			e.printStackTrace();
-			throw new RuntimeException("Exception building memory", e);
-		}
-		endTransaction();
-		return block;
 	}
 
 	public MemoryBlock createUninitializedMemory(String name, String address, int size) {
 
 		startTransaction();
-		Address startAddress = addr(address);
-		Memory memory = program.getMemory();
-		MemoryBlock block = null;
 		try {
-			block = memory.createUninitializedBlock(name, startAddress, size, false);
+			Address startAddress = addr(address);
+			Memory memory = program.getMemory();
+			try {
+				return memory.createUninitializedBlock(name, startAddress, size, false);
+			}
+			catch (Exception e) {
+				throw new RuntimeException("Exception building memory", e);
+			}
 		}
-		catch (Exception e) {
-			throw new RuntimeException("Exception building memory", e);
+		finally {
+			endTransaction();
 		}
-		endTransaction();
-		return block;
 	}
 
 	public MemoryBlock createOverlayMemory(String name, String address, int size) {
@@ -433,15 +443,19 @@ public class ProgramBuilder {
 	public void setBytes(String stringAddress, byte[] bytes, boolean disassemble) throws Exception {
 		Address address = addr(stringAddress);
 		startTransaction();
-		MemoryBlock block = program.getMemory().getBlock(address);
-		if (block == null) {
-			createMemory("Block_" + stringAddress.toString().replace(':', '_'), stringAddress,
-				bytes.length);
-		}
+		try {
+			MemoryBlock block = program.getMemory().getBlock(address);
+			if (block == null) {
+				createMemory("Block_" + stringAddress.toString().replace(':', '_'), stringAddress,
+					bytes.length);
+			}
 
-		Memory memory = program.getMemory();
-		memory.setBytes(address, bytes);
-		endTransaction();
+			Memory memory = program.getMemory();
+			memory.setBytes(address, bytes);
+		}
+		finally {
+			endTransaction();
+		}
 		if (disassemble) {
 			disassemble(stringAddress, bytes.length);
 		}
@@ -449,17 +463,32 @@ public class ProgramBuilder {
 
 	public void setRead(MemoryBlock block, boolean r) {
 		startTransaction();
-		block.setRead(r);
+		try {
+			block.setRead(r);
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	public void setWrite(MemoryBlock block, boolean w) {
 		startTransaction();
-		block.setWrite(w);
+		try {
+			block.setWrite(w);
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	public void setExecute(MemoryBlock block, boolean e) {
 		startTransaction();
-		block.setExecute(e);
+		try {
+			block.setExecute(e);
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	public void disassemble(String addressString, int length) {
@@ -468,71 +497,96 @@ public class ProgramBuilder {
 
 	public void disassemble(String addressString, int length, boolean followFlows) {
 		startTransaction();
-		Address address = addr(addressString);
-		AddressSet addresses = new AddressSet(address, address.add(length - 1));
-		DisassembleCommand cmd = new DisassembleCommand(addresses, addresses, followFlows);
+		try {
+			Address address = addr(addressString);
+			AddressSet addresses = new AddressSet(address, address.add(length - 1));
+			DisassembleCommand cmd = new DisassembleCommand(addresses, addresses, followFlows);
 
-		cmd.applyTo(program);
-		AutoAnalysisManager.getAnalysisManager(program).startAnalysis(TaskMonitor.DUMMY);
-		endTransaction();
+			cmd.applyTo(program);
+			AutoAnalysisManager.getAnalysisManager(program).startAnalysis(TaskMonitor.DUMMY);
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	public void disassemble(AddressSetView set) {
 		startTransaction();
-		DisassembleCommand cmd = new DisassembleCommand(set, set, true);
-		cmd.applyTo(program);
-		AutoAnalysisManager.getAnalysisManager(program).startAnalysis(TaskMonitor.DUMMY);
-		endTransaction();
+		try {
+			DisassembleCommand cmd = new DisassembleCommand(set, set, true);
+			cmd.applyTo(program);
+			AutoAnalysisManager.getAnalysisManager(program).startAnalysis(TaskMonitor.DUMMY);
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	public void disassemble(AddressSetView set, boolean followFlows) {
 		startTransaction();
-		DisassembleCommand cmd = new DisassembleCommand(set, set, followFlows);
-		cmd.applyTo(program);
-		AutoAnalysisManager.getAnalysisManager(program).startAnalysis(TaskMonitor.DUMMY);
-		endTransaction();
+		try {
+			DisassembleCommand cmd = new DisassembleCommand(set, set, followFlows);
+			cmd.applyTo(program);
+			AutoAnalysisManager.getAnalysisManager(program).startAnalysis(TaskMonitor.DUMMY);
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	public void disassembleArm(String addressString, int length, boolean thumb) {
 		startTransaction();
-		Address address = addr(addressString);
-		DisassembleCommand cmd = new ArmDisassembleCommand(address,
-			new AddressSet(address, address.add(length - 1)), true);
-		cmd.applyTo(program);
-		AutoAnalysisManager.getAnalysisManager(program).startAnalysis(TaskMonitor.DUMMY);
-		endTransaction();
-
+		try {
+			Address address = addr(addressString);
+			DisassembleCommand cmd = new ArmDisassembleCommand(address,
+				new AddressSet(address, address.add(length - 1)), true);
+			cmd.applyTo(program);
+			AutoAnalysisManager.getAnalysisManager(program).startAnalysis(TaskMonitor.DUMMY);
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	public void clearCodeUnits(String startAddressString, String endAddressString,
 			boolean clearContext) throws Exception {
 		startTransaction();
-		Address startAddress = addr(startAddressString);
-		Address endAddress = addr(endAddressString);
-		Listing listing = program.getListing();
-		listing.clearCodeUnits(startAddress, endAddress, clearContext);
-		endTransaction();
+		try {
+			Address startAddress = addr(startAddressString);
+			Address endAddress = addr(endAddressString);
+			Listing listing = program.getListing();
+			listing.clearCodeUnits(startAddress, endAddress, clearContext);
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	public Symbol createLabel(String addressString, String name) {
 		startTransaction();
-		Address address = addr(addressString);
-		AddLabelCmd cmd = new AddLabelCmd(address, name, SourceType.USER_DEFINED);
-		cmd.applyTo(program);
-		endTransaction();
-
-		return cmd.getSymbol();
+		try {
+			Address address = addr(addressString);
+			AddLabelCmd cmd = new AddLabelCmd(address, name, SourceType.USER_DEFINED);
+			cmd.applyTo(program);
+			return cmd.getSymbol();
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	public Symbol createLabel(String addressString, String name, String namespace) {
 		startTransaction();
-		Address address = addr(addressString);
-		Namespace ns = getNamespace(namespace, address);
-		AddLabelCmd cmd = new AddLabelCmd(address, name, ns, SourceType.USER_DEFINED);
-		cmd.applyTo(program);
-		endTransaction();
-
-		return cmd.getSymbol();
+		try {
+			Address address = addr(addressString);
+			Namespace ns = getNamespace(namespace, address);
+			AddLabelCmd cmd = new AddLabelCmd(address, name, ns, SourceType.USER_DEFINED);
+			cmd.applyTo(program);
+			return cmd.getSymbol();
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	/**
@@ -543,12 +597,15 @@ public class ProgramBuilder {
 	 */
 	public Function createFunction(String addressString) {
 		startTransaction();
-		Address address = addr(addressString);
-		CreateFunctionCmd cmd = new CreateFunctionCmd(address);
-		cmd.applyTo(program);
-		endTransaction();
-
-		return cmd.getFunction();
+		try {
+			Address address = addr(addressString);
+			CreateFunctionCmd cmd = new CreateFunctionCmd(address);
+			cmd.applyTo(program);
+			return cmd.getFunction();
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	public void addFunctionVariable(Function f, Variable v)
@@ -598,35 +655,39 @@ public class ProgramBuilder {
 			Parameter... params) throws Exception {
 
 		startTransaction();
-		Address entryPoint = addr(address);
-		Address endAddress = entryPoint.add(bodySize - 1);
-		AddressSet body = new AddressSet(entryPoint, endAddress);
-		FunctionManager functionManager = program.getFunctionManager();
+		try {
+			Address entryPoint = addr(address);
+			Address endAddress = entryPoint.add(bodySize - 1);
+			AddressSet body = new AddressSet(entryPoint, endAddress);
+			FunctionManager functionManager = program.getFunctionManager();
 
-		Function function = null;
-		if (namespace == null) {
-			function =
-				functionManager.createFunction(name, entryPoint, body, SourceType.USER_DEFINED);
+			Function function = null;
+			if (namespace == null) {
+				function = functionManager.createFunction(
+					name, entryPoint, body, SourceType.USER_DEFINED);
+			}
+			else {
+				Namespace ns = getNamespace(namespace);
+				function = functionManager.createFunction(
+					name, ns, entryPoint, body, SourceType.USER_DEFINED);
+			}
+
+			if (params == null) {
+				params = new Parameter[0];
+			}
+
+			Variable returnVar = returnType != null ? new ReturnParameterImpl(returnType, program)
+					: function.getReturn();
+			function.updateFunction(callingConventionName, returnVar,
+				customStorage ? FunctionUpdateType.CUSTOM_STORAGE
+						: FunctionUpdateType.DYNAMIC_STORAGE_FORMAL_PARAMS,
+				false, SourceType.USER_DEFINED, params);
+
+			return function;
 		}
-		else {
-			Namespace ns = getNamespace(namespace);
-			function =
-				functionManager.createFunction(name, ns, entryPoint, body, SourceType.USER_DEFINED);
+		finally {
+			endTransaction();
 		}
-
-		if (params == null) {
-			params = new Parameter[0];
-		}
-
-		Variable returnVar = returnType != null ? new ReturnParameterImpl(returnType, program)
-				: function.getReturn();
-		function.updateFunction(callingConventionName, returnVar,
-			customStorage ? FunctionUpdateType.CUSTOM_STORAGE
-					: FunctionUpdateType.DYNAMIC_STORAGE_FORMAL_PARAMS,
-			false, SourceType.USER_DEFINED, params);
-
-		endTransaction();
-		return function;
 	}
 
 	public Function createEmptyFunction(String name, String namespace, String callingConventionName,
@@ -690,31 +751,41 @@ public class ProgramBuilder {
 
 	public Namespace createNamespace(String namespace, String parentNamespace, SourceType type) {
 		startTransaction();
-		Namespace ns = getNamespace(parentNamespace);
-		CreateNamespacesCmd cmd = new CreateNamespacesCmd(namespace, ns, type);
-		cmd.applyTo(program);
-		endTransaction();
-
-		return cmd.getNamespace();
+		try {
+			Namespace ns = getNamespace(parentNamespace);
+			CreateNamespacesCmd cmd = new CreateNamespacesCmd(namespace, ns, type);
+			cmd.applyTo(program);
+			return cmd.getNamespace();
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	public Namespace createClassNamespace(String name, String parentNamespace, SourceType type)
 			throws Exception {
 		startTransaction();
-		Namespace ns = getNamespace(parentNamespace);
-		SymbolTable symbolTable = program.getSymbolTable();
-		GhidraClass c = symbolTable.createClass(ns, name, SourceType.USER_DEFINED);
-		endTransaction();
-
-		return c;
+		try {
+			Namespace ns = getNamespace(parentNamespace);
+			SymbolTable symbolTable = program.getSymbolTable();
+			GhidraClass c = symbolTable.createClass(ns, name, SourceType.USER_DEFINED);
+			return c;
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	public void applyFixedLengthDataType(String addressString, DataType dt, int length)
 			throws CodeUnitInsertionException {
 		startTransaction();
-		DataUtilities.createData(program, addr(addressString), dt, length, false,
-			ClearDataMode.CLEAR_ALL_CONFLICT_DATA);
-		endTransaction();
+		try {
+			DataUtilities.createData(program, addr(addressString), dt, length, false,
+				ClearDataMode.CLEAR_ALL_CONFLICT_DATA);
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	public void applyDataType(String addressString, DataType dt) {
@@ -730,16 +801,20 @@ public class ProgramBuilder {
 	 */
 	public void applyDataType(String addressString, DataType dt, int n) {
 		startTransaction();
-		Address address = addr(addressString);
-		for (int i = 0; i < n; i++) {
-			CreateDataCmd cmd = new CreateDataCmd(address, dt);
-			if (!cmd.applyTo(program)) {
-				throw new AssertException(
-					"Could not apply data at address " + address + ". " + cmd.getStatusMsg());
+		try {
+			Address address = addr(addressString);
+			for (int i = 0; i < n; i++) {
+				CreateDataCmd cmd = new CreateDataCmd(address, dt);
+				if (!cmd.applyTo(program)) {
+					throw new AssertException(
+						"Could not apply data at address " + address + ". " + cmd.getStatusMsg());
+				}
+				address = address.add(dt.getLength());// advance address after cmd succeeds
 			}
-			address = address.add(dt.getLength());// advance address after cmd succeeds
 		}
-		endTransaction();
+		finally {
+			endTransaction();
+		}
 	}
 
 	/**
@@ -805,31 +880,43 @@ public class ProgramBuilder {
 	public Reference createMemoryReference(String fromAddress, String toAddress, RefType refType,
 			SourceType sourceType, int opIndex) {
 		startTransaction();
-		ReferenceManager refManager = program.getReferenceManager();
-		Reference ref = refManager.addMemoryReference(addr(fromAddress), addr(toAddress), refType,
-			sourceType, opIndex);
-		endTransaction();
-		return ref;
+		try {
+			ReferenceManager refManager = program.getReferenceManager();
+			Reference ref = refManager.addMemoryReference(addr(fromAddress), addr(toAddress),
+				refType, sourceType, opIndex);
+			return ref;
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	public Reference createOffsetMemReference(String fromAddress, String toAddress, int offset,
 			RefType refType, SourceType sourceType, int opIndex) {
 		startTransaction();
-		ReferenceManager refManager = program.getReferenceManager();
-		Reference ref = refManager.addOffsetMemReference(addr(fromAddress), addr(toAddress), offset,
-			refType, sourceType, opIndex);
-		endTransaction();
-		return ref;
+		try {
+			ReferenceManager refManager = program.getReferenceManager();
+			Reference ref = refManager.addOffsetMemReference(addr(fromAddress), addr(toAddress),
+				offset, refType, sourceType, opIndex);
+			return ref;
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	public Reference createStackReference(String fromAddress, RefType refType, int stackOffset,
 			SourceType sourceType, int opIndex) {
 		startTransaction();
-		ReferenceManager refManager = program.getReferenceManager();
-		Reference ref = refManager.addStackReference(addr(fromAddress), opIndex, stackOffset,
-			refType, sourceType);
-		endTransaction();
-		return ref;
+		try {
+			ReferenceManager refManager = program.getReferenceManager();
+			Reference ref = refManager.addStackReference(addr(fromAddress), opIndex, stackOffset,
+				refType, sourceType);
+			return ref;
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	public Reference createRegisterReference(String fromAddress, String registerName, int opIndex) {
@@ -840,33 +927,45 @@ public class ProgramBuilder {
 	public Reference createRegisterReference(String fromAddress, RefType refType,
 			String registerName, SourceType sourceType, int opIndex) {
 		startTransaction();
-		ReferenceManager refManager = program.getReferenceManager();
-		Register register = program.getRegister(registerName);
-		Reference ref = refManager.addRegisterReference(addr(fromAddress), opIndex, register,
-			refType, sourceType);
-		endTransaction();
-		return ref;
+		try {
+			ReferenceManager refManager = program.getReferenceManager();
+			Register register = program.getRegister(registerName);
+			Reference ref = refManager.addRegisterReference(addr(fromAddress), opIndex, register,
+				refType, sourceType);
+			return ref;
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	public Symbol createEntryPoint(String addressString, String name)
 			throws DuplicateNameException, InvalidInputException {
 		startTransaction();
-		SymbolTable symbolTable = program.getSymbolTable();
-		symbolTable.addExternalEntryPoint(addr(addressString));
-		Symbol[] symbols = symbolTable.getSymbols(addr(addressString));
-		symbols[0].setName(name, SourceType.ANALYSIS);
-		endTransaction();
-		return symbols[0];
+		try {
+			SymbolTable symbolTable = program.getSymbolTable();
+			symbolTable.addExternalEntryPoint(addr(addressString));
+			Symbol[] symbols = symbolTable.getSymbols(addr(addressString));
+			symbols[0].setName(name, SourceType.ANALYSIS);
+			return symbols[0];
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	public Bookmark createBookmark(String address, String bookmarkType, String category,
 			String comment) {
 		startTransaction();
-		BookmarkManager bookMgr = program.getBookmarkManager();
-		Address addr = addr(address);
-		Bookmark bm = bookMgr.setBookmark(addr, bookmarkType, category, comment);
-		endTransaction();
-		return bm;
+		try {
+			BookmarkManager bookMgr = program.getBookmarkManager();
+			Address addr = addr(address);
+			Bookmark bm = bookMgr.setBookmark(addr, bookmarkType, category, comment);
+			return bm;
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	public void createEncodedString(String address, String string, Charset encoding,
@@ -910,56 +1009,84 @@ public class ProgramBuilder {
 		setBytes(address, stringBytes);
 		if (dataType != null) {
 			startTransaction();
-			Data data = DataUtilities.createData(program, addr, dataType, stringBytes.length, false,
-				ClearDataMode.CLEAR_ALL_UNDEFINED_CONFLICT_DATA);
-			CharsetSettingsDefinition.CHARSET.setCharset(data, charset.name());
-			endTransaction();
-			return data;
+			try {
+				Data data = DataUtilities.createData(program, addr, dataType, stringBytes.length,
+					false, ClearDataMode.CLEAR_ALL_UNDEFINED_CONFLICT_DATA);
+				CharsetSettingsDefinition.CHARSET.setCharset(data, charset.name());
+				return data;
+			}
+			finally {
+				endTransaction();
+			}
 		}
 		return null;
 	}
 
 	public void setProperty(String name, Object value) {
 		startTransaction();
-		Options options = program.getOptions(Program.PROGRAM_INFO);
-		options.putObject(name, value);
-		endTransaction();
+		try {
+			Options options = program.getOptions(Program.PROGRAM_INFO);
+			options.putObject(name, value);
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	public void setAnalysisEnabled(String name, boolean enabled) {
 		startTransaction();
-		Options options = program.getOptions(Program.ANALYSIS_PROPERTIES);
-		options.setBoolean(name, enabled);
-		endTransaction();
+		try {
+			Options options = program.getOptions(Program.ANALYSIS_PROPERTIES);
+			options.setBoolean(name, enabled);
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	public void addDataType(DataType dt) {
 		startTransaction();
-		ProgramDataTypeManager dtm = program.getDataTypeManager();
-		dtm.addDataType(dt, DataTypeConflictHandler.REPLACE_HANDLER);
-		endTransaction();
+		try {
+			ProgramDataTypeManager dtm = program.getDataTypeManager();
+			dtm.addDataType(dt, DataTypeConflictHandler.REPLACE_HANDLER);
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	public void addCategory(CategoryPath path) {
 		startTransaction();
-		ProgramDataTypeManager dtm = program.getDataTypeManager();
-		dtm.createCategory(path);
-		endTransaction();
+		try {
+			ProgramDataTypeManager dtm = program.getDataTypeManager();
+			dtm.createCategory(path);
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	public void createProgramTree(String treeName) throws Exception {
 		startTransaction();
-		program.getListing().createRootModule(treeName);
-		endTransaction();
+		try {
+			program.getListing().createRootModule(treeName);
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	public void createFragment(String treeName, String modulePath, String fragmentName,
 			String startAddr, String endAddr) throws Exception {
 		startTransaction();
-		ProgramModule module = getOrCreateModule(treeName, modulePath);
-		ProgramFragment fragment = module.createFragment(fragmentName);
-		fragment.move(addr(startAddr), addr(endAddr));
-		endTransaction();
+		try {
+			ProgramModule module = getOrCreateModule(treeName, modulePath);
+			ProgramFragment fragment = module.createFragment(fragmentName);
+			fragment.move(addr(startAddr), addr(endAddr));
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	public ProgramModule getOrCreateModule(String treeName, String modulePath) throws Exception {
@@ -996,40 +1123,50 @@ public class ProgramBuilder {
 
 	public Equate createEquate(String address, String name, long value, int opIndex) {
 		startTransaction();
-		SetEquateCmd cmd = new SetEquateCmd(name, addr(address), opIndex, value);
-		cmd.applyTo(program);
-		Equate equate = cmd.getEquate();
-		endTransaction();
-		return equate;
+		try {
+			SetEquateCmd cmd = new SetEquateCmd(name, addr(address), opIndex, value);
+			cmd.applyTo(program);
+			return cmd.getEquate();
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	public void createComment(String address, String comment, int commentType) {
 		startTransaction();
-
-		Listing listing = program.getListing();
-		listing.setComment(addr(address), commentType, comment);
-		endTransaction();
+		try {
+			Listing listing = program.getListing();
+			listing.setComment(addr(address), commentType, comment);
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	public void createFunctionComment(String entryPointAddress, String comment) {
 		startTransaction();
-
-		FunctionManager functionManager = program.getFunctionManager();
-		Address addr = addr(entryPointAddress);
-		Function function = functionManager.getFunctionAt(addr);
-		function.setComment(comment);
-
-		endTransaction();
+		try {
+			FunctionManager functionManager = program.getFunctionManager();
+			Address addr = addr(entryPointAddress);
+			Function function = functionManager.getFunctionAt(addr);
+			function.setComment(comment);
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	public void setFallthrough(String from, String to) {
 		startTransaction();
-
-		Listing listing = program.getListing();
-		Instruction inst = listing.getInstructionAt(addr(from));
-		inst.setFallThrough(addr(to));
-
-		endTransaction();
+		try {
+			Listing listing = program.getListing();
+			Instruction inst = listing.getInstructionAt(addr(from));
+			inst.setFallThrough(addr(to));
+		}
+		finally {
+			endTransaction();
+		}
 	}
 
 	public void createExternalLibraries(String... libraryNames) throws Exception {