GP-1519 Changed getComponentAt to getComponentContaining in a breaking EditStructureUtils method and a couple other places. Various refactoring to clean up code.

Ghidra/Features/Decompiler/ghidra_scripts/RecoverClassesFromRTTIScript.java

@@ -165,8 +165,6 @@ public class RecoverClassesFromRTTIScript extends GhidraScript {
 
 	RTTIClassRecoverer recoverClassesFromRTTI;
 
-	ExtraScriptUtils extraUtils;
-
 	boolean nameVfunctions = false;
 
 	@Override

Ghidra/Features/Decompiler/ghidra_scripts/classrecovery/EditStructureUtils.java

@@ -22,9 +22,9 @@ import ghidra.program.model.data.*;
 import ghidra.util.exception.CancelledException;
 import ghidra.util.task.TaskMonitor;
 
-public class EditStructureUtils {
+class EditStructureUtils {
 
-	EditStructureUtils() {
+	private EditStructureUtils() {
 
 	}
 
@@ -42,7 +42,7 @@ public class EditStructureUtils {
 	 * internal struct, false otherwise
 	 * @throws CancelledException if cancelled
 	 */
-	public boolean hasReplaceableComponentsAtOffset(Structure containingStruct, int offset,
+	static boolean hasReplaceableComponentsAtOffset(Structure containingStruct, int offset,
 			Structure newInternalStruct, TaskMonitor monitor) throws CancelledException {
 
 		DataTypeComponent[] newStructComponents = newInternalStruct.getComponents();
@@ -95,7 +95,7 @@ public class EditStructureUtils {
 	 * @return true if there are at least length undefined size 1 components at the given offset in the given structure
 	 * @throws CancelledException if cancelled
 	 */
-	public boolean hasEnoughUndefined1sAtOffset(Structure structure, int offset, int length,
+	static boolean hasEnoughUndefined1sAtOffset(Structure structure, int offset, int length,
 			TaskMonitor monitor) throws CancelledException {
 
 		if (structure.getLength() < offset + length) {
@@ -128,7 +128,7 @@ public class EditStructureUtils {
 	 * @return true if successfully cleared from offset to offset+length, false otherwise
 	 * @throws CancelledException if cancelled
 	 */
-	public boolean clearLengthAtOffset(Structure structure, int offset, int length,
+	static boolean clearLengthAtOffset(Structure structure, int offset, int length,
 			TaskMonitor monitor) throws CancelledException {
 
 		if (structure.getLength() < offset + length) {
@@ -143,17 +143,10 @@ public class EditStructureUtils {
 
 			monitor.checkCanceled();
 
-			DataTypeComponent component = structure.getComponentAt(offset);
-			DataType dataType = component.getDataType();
+			DataTypeComponent component = structure.getComponentContaining(offset);
 
-			// return false if it would clear too much
-			if (offset + dataType.getLength() > endOfClear) {
-				return false;
-			}
-
-			offsetsToClear.add(offset);
-			offset += dataType.getLength();
-			continue;
+			offsetsToClear.add(component.getOffset());
+			offset = component.getOffset() + component.getLength();
 
 		}
 
@@ -178,11 +171,12 @@ public class EditStructureUtils {
 	 * @param dataType the given data type
 	 * @return true if given data type is undefined size 1, false otherwise
 	 */
-	public boolean isUndefined1(DataType dataType) {
+	static boolean isUndefined1(DataType dataType) {
 
-		if (isUndefined(dataType) && dataType.getLength() == 1) {
+		if (Undefined.isUndefined(dataType) && dataType.getLength() == 1) {
 			return true;
 		}
+
 		return false;
 	}
 
@@ -191,7 +185,7 @@ public class EditStructureUtils {
 	 * @param dataType the given data type
 	 * @return true if given data type is undefined of any size, false otherwise
 	 */
-	public boolean isUndefined(DataType dataType) {
+	static boolean isUndefined(DataType dataType) {
 		if (dataType.getName().contains("undefined")) {
 			return true;
 		}
@@ -199,41 +193,46 @@ public class EditStructureUtils {
 	}
 
 	/**
-	 * Method to determine if there are at least the given length of undefined (any size) components at the given offset in the given structure
+	 * Method to determine if there are at least the given length of undefined (any size) components 
+	 * at the given offset in the given structure. This is only valid for non-packed structures.
 	 * @param structure the given structure
 	 * @param offset the given offset
 	 * @param length the total length of undefined components to check for starting at given offset
 	 * @param monitor task monitor
 	 * @return true if there are at least total length of undefined components at the given offset in the given structure
 	 * @throws CancelledException if cancelled
+	 * @throws IllegalArgumentException if a packed structure is passed in
 	 */
-	public boolean hasEnoughUndefinedsOfAnyLengthAtOffset(Structure structure, int offset,
+	static boolean hasEnoughUndefinedsOfAnyLengthAtOffset(Structure structure, int offset,
 			int length, TaskMonitor monitor) throws CancelledException {
 
-		if (structure.getLength() < offset + length) {
-			return false;
+		if (structure.isPackingEnabled()) {
+			throw new IllegalArgumentException(
+				"Packed structures are not supported by this method");
 		}
 
 		int endOfRange = offset + length;
 
+		if (offset < 0 || length <= 0 || structure.getLength() < endOfRange) {
+			return false;
+		}
+
 		while (offset < endOfRange) {
 
 			monitor.checkCanceled();
 
-			DataTypeComponent component = structure.getComponentAt(offset);
+			DataTypeComponent component = structure.getComponentContaining(offset);
+
 			DataType dataType = component.getDataType();
-			if (isUndefined(dataType)) {
-
-				offset += dataType.getLength();
-				if (offset > endOfRange) {
-					return false;
-				}
-
-				continue;
 
+			if (!Undefined.isUndefined(dataType)) {
+				return false;
 			}
-			return false;
+
+			offset = component.getOffset() + component.getLength();
+
 		}
+
 		return true;
 	}
 
@@ -251,7 +250,7 @@ public class EditStructureUtils {
 	 * @throws IllegalArgumentException if issue inserting data type into structure
 	 * @throws CancelledException if cancelled
 	 */
-	public Structure addDataTypeToStructure(Structure structure, int offset,
+	static Structure addDataTypeToStructure(Structure structure, int offset,
 			DataType dataType, String fieldName, TaskMonitor monitor)
 			throws CancelledException, IllegalArgumentException {
 
@@ -292,7 +291,7 @@ public class EditStructureUtils {
 	 * @return true if the given structure has room at the given offset to have a component of the given length added to it
 	 * @throws CancelledException if cancelled
 	 */
-	public boolean canAdd(Structure structureDataType, int offset, int lengthToAdd,
+	static boolean canAdd(Structure structureDataType, int offset, int lengthToAdd,
 			TaskMonitor monitor)
 			throws CancelledException {
 
@@ -332,7 +331,7 @@ public class EditStructureUtils {
 	 * @return the number of undefined size 1 components in the given structure before the given offset
 	 * @throws CancelledException if cancelled
 	 */
-	public int getNumberOfUndefinedsBeforeOffset(Structure structure, int offset,
+	static int getNumberOfUndefinedsBeforeOffset(Structure structure, int offset,
 			TaskMonitor monitor) throws CancelledException {
 
 		if (structure.getNumComponents() == 0) {
@@ -364,7 +363,7 @@ public class EditStructureUtils {
 	 * @return the number of undefined size 1 components starting at the given offset in the given structure
 	 * @throws CancelledException if cancelled
 	 */
-	public int getNumberOfUndefinedsStartingAtOffset(Structure structure, int offset,
+	static int getNumberOfUndefinedsStartingAtOffset(Structure structure, int offset,
 			TaskMonitor monitor) throws CancelledException {
 
 		int numUndefineds = 0;

Ghidra/Features/Decompiler/ghidra_scripts/classrecovery/ExtendedFlatProgramAPI.java

@@ -34,19 +34,13 @@ import ghidra.program.model.symbol.*;
 import ghidra.util.exception.*;
 import ghidra.util.task.TaskMonitor;
 
-public class ExtraScriptUtils extends FlatProgramAPI {
+public class ExtendedFlatProgramAPI extends FlatProgramAPI {
 
-	Program program;
-	TaskMonitor taskMonitor;
-	int defaultPointerSize;
+	final int defaultPointerSize;
 
-	ExtraScriptUtils(Program program, TaskMonitor taskMonitor) {
-		this.program = program;
-		this.taskMonitor = taskMonitor;
-
-		currentProgram = program;
-		monitor = taskMonitor;
+	ExtendedFlatProgramAPI(Program program, TaskMonitor taskMonitor) {
 
+		super(program, taskMonitor);
 		defaultPointerSize = program.getDefaultPointerSize();
 	}
 
@@ -66,7 +60,7 @@ public class ExtraScriptUtils extends FlatProgramAPI {
 		int numComponents = data.getNumComponents();
 
 		for (int ii = 0; ii < numComponents; ++ii) {
-			taskMonitor.checkCanceled();
+			monitor.checkCanceled();
 
 			Data component = data.getComponent(ii);
 			if (!component.isPointer()) {
@@ -125,7 +119,7 @@ public class ExtraScriptUtils extends FlatProgramAPI {
 		}
 
 		// check for or create function pointer if valid function pointed to
-		Data data = program.getListing().getDefinedDataAt(address);
+		Data data = currentProgram.getListing().getDefinedDataAt(address);
 		if (data != null) {
 			if (data.isPointer() && getPointedToFunction(address) != null) {
 				return true;
@@ -165,8 +159,8 @@ public class ExtraScriptUtils extends FlatProgramAPI {
 			return false;
 		}
 
-		DataType nullPointer = program.getDataTypeManager().getPointer(null);
-		Listing listing = program.getListing();
+		DataType nullPointer = currentProgram.getDataTypeManager().getPointer(null);
+		Listing listing = currentProgram.getListing();
 		Data d = listing.getDefinedDataAt(address);
 		if (d == null) {
 			try {
@@ -316,7 +310,7 @@ public class ExtraScriptUtils extends FlatProgramAPI {
 	 */
 	public Function createFunctionBefore(Address address, Byte expectedFiller) {
 
-		PseudoDisassembler pseudoDisassembler = new PseudoDisassembler(program);
+		PseudoDisassembler pseudoDisassembler = new PseudoDisassembler(currentProgram);
 
 		Instruction instructionBefore = getInstructionBefore(address);
 
@@ -419,7 +413,7 @@ public class ExtraScriptUtils extends FlatProgramAPI {
 	public int getNumberOfSameFillerBytesStartingAtAddress(Address firstAddress)
 			throws CancelledException, MemoryAccessException {
 
-		AddressSetView validMemory = program.getMemory().getLoadedAndInitializedAddressSet();
+		AddressSetView validMemory = currentProgram.getMemory().getLoadedAndInitializedAddressSet();
 
 		if (firstAddress == null) {
 			return 0;
@@ -529,7 +523,7 @@ public class ExtraScriptUtils extends FlatProgramAPI {
 		// Create a new address set to hold the entire selection.
 		AddressSet subroutineAddresses = new AddressSet();
 
-		IsolatedEntrySubModel model = new IsolatedEntrySubModel(program);
+		IsolatedEntrySubModel model = new IsolatedEntrySubModel(currentProgram);
 		CodeBlock[] codeBlocksContaining = model.getCodeBlocksContaining(address, monitor);
 
 		for (CodeBlock element : codeBlocksContaining) {
@@ -607,7 +601,7 @@ public class ExtraScriptUtils extends FlatProgramAPI {
 		int addressSize = address.getSize();
 		if (addressSize == 64 && getIboIf64bit) {
 			ImageBaseOffset32DataType ibo32 =
-				new ImageBaseOffset32DataType(program.getDataTypeManager());
+				new ImageBaseOffset32DataType(currentProgram.getDataTypeManager());
 			int length = ibo32.getLength();
 			DumbMemBufferImpl compMemBuffer =
 				new DumbMemBufferImpl(currentProgram.getMemory(), address);
@@ -654,7 +648,7 @@ public class ExtraScriptUtils extends FlatProgramAPI {
 
 		List<Symbol> symbolList = new ArrayList<Symbol>();
 
-		SymbolIterator symbols = program.getSymbolTable().getSymbols(namespace);
+		SymbolIterator symbols = currentProgram.getSymbolTable().getSymbols(namespace);
 
 		while (symbols.hasNext()) {
 			monitor.checkCanceled();
@@ -765,7 +759,7 @@ public class ExtraScriptUtils extends FlatProgramAPI {
 		List<Address> referenceAddresses = new ArrayList<Address>();
 
 		ReferenceIterator referencesToFunctionBIterator =
-			program.getReferenceManager().getReferencesTo(bFunction.getEntryPoint());
+			currentProgram.getReferenceManager().getReferencesTo(bFunction.getEntryPoint());
 
 		while (referencesToFunctionBIterator.hasNext()) {
 
@@ -995,7 +989,7 @@ public class ExtraScriptUtils extends FlatProgramAPI {
 	 */
 	public void removeAllSymbolsAtAddress(Address address) throws CancelledException {
 
-		SymbolTable symbolTable = program.getSymbolTable();
+		SymbolTable symbolTable = currentProgram.getSymbolTable();
 
 		Symbol primarySymbol = symbolTable.getPrimarySymbol(address);
 
@@ -1031,7 +1025,7 @@ public class ExtraScriptUtils extends FlatProgramAPI {
 	 */
 	public boolean hasSymbolsInNamespace(Namespace namespace) {
 
-		SymbolIterator namespaceSymbols = program.getSymbolTable().getSymbols(namespace);
+		SymbolIterator namespaceSymbols = currentProgram.getSymbolTable().getSymbols(namespace);
 
 		if (namespaceSymbols.hasNext()) {
 			return true;

Ghidra/Features/Decompiler/ghidra_scripts/classrecovery/RTTIClassRecoverer.java

@@ -161,7 +161,7 @@ public class RTTIClassRecoverer extends RecoveredClassUtils {
 			// if class is non-virtual have to search for an existing class datatype
 			if (!recoveredClass.hasVftable()) {
 				DataType[] possibleExistingClassStructures =
-					extraUtils.getDataTypes(recoveredClass.getName());
+					extendedFlatAPI.getDataTypes(recoveredClass.getName());
 				if (possibleExistingClassStructures.length == 0) {
 					continue;
 				}

Ghidra/Features/Decompiler/ghidra_scripts/classrecovery/RTTIGccClassRecoverer.java

@@ -253,7 +253,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
 		recoveredClasses = recoverClassesFromVftables(vftableSymbols, true, true);
 
 		// find all typeinfo symbols and get their class namespace and create RecoveredClass object
-		List<Symbol> typeinfoSymbols = extraUtils.getListOfSymbolsInAddressSet(
+		List<Symbol> typeinfoSymbols = extendedFlatAPI.getListOfSymbolsInAddressSet(
 			program.getAddressFactory().getAddressSet(), "typeinfo", true);
 
 		// create class objects for each typeinfo struct and make a class to typeinfo mapping for each		
@@ -325,7 +325,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
 				}
 			}
 
-			Address specialTypeinfoRef = extraUtils.getSingleReferencedAddress(typeinfoAddress);
+			Address specialTypeinfoRef = extendedFlatAPI.getSingleReferencedAddress(typeinfoAddress);
 			if (specialTypeinfoRef == null) {
 				if (DEBUG) {
 					Msg.debug(this,
@@ -454,7 +454,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
 			listOfVtableSymbols = findVtablesUsingTypeinfoRefs();
 		}
 		else {
-			listOfVtableSymbols = extraUtils.getListOfSymbolsInAddressSet(
+			listOfVtableSymbols = extendedFlatAPI.getListOfSymbolsInAddressSet(
 				program.getAddressFactory().getAddressSet(), VTABLE_LABEL, false);
 		}
 
@@ -496,7 +496,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
 		for (Address typeinfoRef : typeinfoReferencesNotInTypeinfoStructs) {
 			monitor.checkCanceled();
 
-			Address typeinfoAddress = extraUtils.getPointer(typeinfoRef);
+			Address typeinfoAddress = extendedFlatAPI.getPointer(typeinfoRef);
 
 			if (typeinfoAddress == null) {
 				continue;
@@ -563,7 +563,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
 		// check for appropriately sized long that is value 0 to make sure the 
 		// vtable the typeinfo ref is in is the main one and skip otherwise since non-zero
 		// ones are internal vtables that will get processed with the main one
-		if (!extraUtils.hasNumZeros(longBeforeTypeinfoRef, defaultPointerSize)) {
+		if (!extendedFlatAPI.hasNumZeros(longBeforeTypeinfoRef, defaultPointerSize)) {
 			return null;
 		}
 
@@ -590,7 +590,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
 
 	private Address getPointerToDefinedMemory(Address address) {
 
-		Address pointer = extraUtils.getPointer(address);
+		Address pointer = extendedFlatAPI.getPointer(address);
 		if (pointer == null) {
 			return null;
 		}
@@ -966,7 +966,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
 	private Symbol getVTTBefore(Address address) throws CancelledException {
 
 		// get all symbols named VTT and get the one directly before the given address
-		List<Symbol> vttSymbols = extraUtils.getListOfSymbolsInAddressSet(
+		List<Symbol> vttSymbols = extendedFlatAPI.getListOfSymbolsInAddressSet(
 			program.getAddressFactory().getAddressSet(), "VTT", true);
 
 		return getSymbolOnListBeforeAddress(address, vttSymbols);
@@ -1210,7 +1210,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
 				return false;
 			}
 
-			Reference[] referencesTo = extraUtils.getReferencesTo(address);
+			Reference[] referencesTo = extendedFlatAPI.getReferencesTo(address);
 			if (referencesTo.length > 0) {
 				return false;
 			}
@@ -1239,7 +1239,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
 				return false;
 			}
 
-			List<Address> referenceFromAddresses = extraUtils.getReferenceFromAddresses(address);
+			List<Address> referenceFromAddresses = extendedFlatAPI.getReferenceFromAddresses(address);
 
 			if (referenceFromAddresses.size() > 0) {
 				return false;
@@ -1304,7 +1304,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
 			return false;
 		}
 
-		if (extraUtils.hasNumZeros(vftableAddress, defaultPointerSize)) {
+		if (extendedFlatAPI.hasNumZeros(vftableAddress, defaultPointerSize)) {
 			return true;
 		}
 
@@ -1313,7 +1313,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
 			if (!data.isPointer()) {
 				return false;
 			}
-			Address referencedAddress = extraUtils.getSingleReferencedAddress(vftableAddress);
+			Address referencedAddress = extendedFlatAPI.getSingleReferencedAddress(vftableAddress);
 			if (referencedAddress == null) {
 				return false;
 			}
@@ -1407,7 +1407,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
 			// create a pointer and check to see if it is a reference to a valid memory location
 			try {
 				api.createData(address, pointer);
-				Address referencedAddress = extraUtils.getSingleReferencedAddress(address);
+				Address referencedAddress = extendedFlatAPI.getSingleReferencedAddress(address);
 
 				// if it isn't valid, clear what we just created and increment to offset so
 				// the next can be checked
@@ -1464,7 +1464,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
 
 		for (Address typeinfoAddress : typeinfoAddresses) {
 
-			Address specialTypeinfoRef = extraUtils.getSingleReferencedAddress(typeinfoAddress);
+			Address specialTypeinfoRef = extendedFlatAPI.getSingleReferencedAddress(typeinfoAddress);
 			if (specialTypeinfoRef == null) {
 				continue;
 			}
@@ -1698,7 +1698,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
 		}
 
 		Address stringReference =
-			extraUtils.getSingleReferencedAddress(address.add(typeinfoNameComponent.getOffset()));
+			extendedFlatAPI.getSingleReferencedAddress(address.add(typeinfoNameComponent.getOffset()));
 
 		Data stringData = api.getDataAt(stringReference);
 		if (stringData == null) {
@@ -1728,7 +1728,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
 
 		List<Address> typeinfoAddresses = new ArrayList<Address>();
 
-		List<Symbol> typeinfoSymbols = extraUtils.getListOfSymbolsInAddressSet(
+		List<Symbol> typeinfoSymbols = extendedFlatAPI.getListOfSymbolsInAddressSet(
 			program.getAddressFactory().getAddressSet(), "typeinfo", true);
 
 		Iterator<Symbol> typeinfoIterator = typeinfoSymbols.iterator();
@@ -2153,8 +2153,8 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
 			//virtual base offset for the virtual base referenced (negative).
 			long offset = (publicVirtualOffsetFlag & offsetMask) >> 8;
 
-			Msg.debug(this, "typeinfo " + typeinfoAddress + " base [" + i + "] isVirtual = " +
-				isVirtual + " isPublic = " + isPublic + " offset = " + offset);
+//			Msg.debug(this, "typeinfo " + typeinfoAddress + " base [" + i + "] isVirtual = " +
+//				isVirtual + " isPublic = " + isPublic + " offset = " + offset);
 
 			// add order to parent and parent offset
 			orderToParentMap.put(i, parentClass);
@@ -2207,7 +2207,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
 	 */
 	private RecoveredClass getParentClassFromParentTypeInfoRef(Address parentTypeinfoRef) {
 
-		Address parentAddress = extraUtils.getSingleReferencedAddress(parentTypeinfoRef);
+		Address parentAddress = extendedFlatAPI.getSingleReferencedAddress(parentTypeinfoRef);
 		if (parentAddress == null) {
 			return null;
 		}
@@ -2295,7 +2295,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
 
 		int offset = 0;
 
-		Address address = extraUtils.getAddress(startAddress, offset);
+		Address address = extendedFlatAPI.getAddress(startAddress, offset);
 
 		MemoryBlock currentMemoryBlock = program.getMemory().getBlock(startAddress);
 
@@ -2309,10 +2309,10 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
 				return null;
 			}
 
-			Address possibleTypeinfo = extraUtils.getPointer(address);
+			Address possibleTypeinfo = extendedFlatAPI.getPointer(address);
 			if (possibleTypeinfo == null) {
 				offset += defaultPointerSize;
-				address = extraUtils.getAddress(startAddress, offset);
+				address = extendedFlatAPI.getAddress(startAddress, offset);
 				continue;
 			}
 
@@ -2322,7 +2322,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
 				return address;
 			}
 			offset += defaultPointerSize;
-			address = extraUtils.getAddress(startAddress, offset);
+			address = extendedFlatAPI.getAddress(startAddress, offset);
 
 		}
 
@@ -2339,7 +2339,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
 		List<Symbol> vftableSymbols = new ArrayList<Symbol>();
 
 		// find all vtable symbols
-		List<Symbol> listOfVtableSymbols = extraUtils.getListOfSymbolsInAddressSet(
+		List<Symbol> listOfVtableSymbols = extendedFlatAPI.getListOfSymbolsInAddressSet(
 			program.getAddressFactory().getAddressSet(), VTABLE_LABEL, true);
 
 		Iterator<Symbol> vtableIterator = listOfVtableSymbols.iterator();
@@ -2373,7 +2373,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
 				continue;
 			}
 
-			Address vftableAddress = extraUtils.getAddress(typeinfoAddress, defaultPointerSize);
+			Address vftableAddress = extendedFlatAPI.getAddress(typeinfoAddress, defaultPointerSize);
 			// no valid address here so continue
 			if (vftableAddress == null) {
 				//createNewClass(vtableNamespace, false);
@@ -2454,7 +2454,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
 				recoveredClasses.add(recoveredClass);
 			}
 
-			Address specialTypeinfoRef = extraUtils.getSingleReferencedAddress(typeinfoAddress);
+			Address specialTypeinfoRef = extendedFlatAPI.getSingleReferencedAddress(typeinfoAddress);
 			if (specialTypeinfoRef == null) {
 				if (DEBUG) {
 					Msg.debug(this,
@@ -2759,7 +2759,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
 	 * @return true if the given address could be a valid null pointer, false if not
 	 */
 	private boolean isPossibleNullPointer(Address address) throws CancelledException {
-		if (!extraUtils.hasNumZeros(address, defaultPointerSize)) {
+		if (!extendedFlatAPI.hasNumZeros(address, defaultPointerSize)) {
 			return false;
 		}
 		return true;
@@ -2772,7 +2772,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
 	 */
 	private boolean isPossibleFunctionPointer(Address address) {
 
-		Address possibleFunctionPointer = extraUtils.getPointer(address);
+		Address possibleFunctionPointer = extendedFlatAPI.getPointer(address);
 		if (possibleFunctionPointer == null) {
 			return false;
 		}
@@ -2967,9 +2967,11 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
 			DataType classVftablePointer = vfPointerDataTypes.get(vftableAddress);
 
 			// simple case the offset for vftablePtr is 0
-			if (structUtils.canAdd(classStructureDataType, 0, classVftablePointer.getLength(),
+			if (EditStructureUtils.canAdd(classStructureDataType, 0,
+				classVftablePointer.getLength(),
 				monitor)) {
-				classStructureDataType = structUtils.addDataTypeToStructure(classStructureDataType,
+				classStructureDataType =
+					EditStructureUtils.addDataTypeToStructure(classStructureDataType,
 					0, classVftablePointer, CLASS_VTABLE_PTR_FIELD_EXT, monitor);
 
 			}
@@ -3013,10 +3015,11 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
 						" : structure should exist but doesn't.");
 				}
 
-				if (structUtils.canAdd(classStructureDataType, parentOffset,
+				if (EditStructureUtils.canAdd(classStructureDataType, parentOffset,
 					baseClassStructure.getLength(), monitor)) {
 					classStructureDataType =
-						structUtils.addDataTypeToStructure(classStructureDataType, parentOffset,
+						EditStructureUtils.addDataTypeToStructure(classStructureDataType,
+							parentOffset,
 							baseClassStructure, baseClassStructure.getName(), monitor);
 				}
 			}
@@ -3027,7 +3030,8 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
 		int dataOffset = getDataOffset(recoveredClass, classStructureDataType);
 		int dataLen = UNKNOWN;
 		if (dataOffset != NONE) {
-			dataLen = structUtils.getNumberOfUndefinedsStartingAtOffset(classStructureDataType,
+			dataLen =
+				EditStructureUtils.getNumberOfUndefinedsStartingAtOffset(classStructureDataType,
 				dataOffset, monitor);
 		}
 
@@ -3037,7 +3041,8 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
 				classStructureDataType, dataLen, dataOffset);
 
 			if (recoveredClassDataStruct != null) {
-				classStructureDataType = structUtils.addDataTypeToStructure(classStructureDataType,
+				classStructureDataType = EditStructureUtils.addDataTypeToStructure(
+					classStructureDataType,
 					dataOffset, recoveredClassDataStruct, "data", monitor);
 			}
 

Ghidra/Features/Decompiler/ghidra_scripts/classrecovery/RTTIWindowsClassRecoverer.java

@@ -190,7 +190,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 			figureOutClassDataMembers(recoveredClasses);
 
 			if (USE_SHORT_TEMPLATE_NAMES_IN_STRUCTURE_FIELDS) {
-				extraUtils.createShortenedTemplateNamesForClasses(recoveredClasses);
+				extendedFlatAPI.createShortenedTemplateNamesForClasses(recoveredClasses);
 			}
 
 			createAndApplyClassStructures(recoveredClasses);
@@ -336,7 +336,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 				continue;
 			}
 
-			Data data = extraUtils.getDataAt(symbol.getAddress());
+			Data data = extendedFlatAPI.getDataAt(symbol.getAddress());
 			if (data != null &&
 				data.getDataType().getName().contains(RTTI_BASE_COMPLETE_OBJECT_LOADER_DATA_NAME)) {
 				completeObjectLocatorSymbols.add(symbol);
@@ -375,7 +375,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 		int sizeOfDt = completeObjLocatorDataType.getLength();
 
 		api.clearListing(address, address.add(sizeOfDt));
-		Data completeObjectLocator = extraUtils.createData(address, completeObjLocatorDataType);
+		Data completeObjectLocator = extendedFlatAPI.createData(address, completeObjLocatorDataType);
 		if (completeObjectLocator == null) {
 			return null;
 		}
@@ -402,7 +402,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 				continue;
 			}
 
-			Data data = extraUtils.getDataAt(symbol.getAddress());
+			Data data = extendedFlatAPI.getDataAt(symbol.getAddress());
 			if (data != null &&
 				data.getDataType().getName().contains(RTTI_BASE_CLASS_DESCRIPTOR_DATA_NAME)) {
 				baseClassDescriptorSymbols.add(symbol);
@@ -440,7 +440,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 
 		api.clearListing(baseClassDescriptorAddress, baseClassDescriptorAddress.add(sizeOfDt));
 		Data baseClassDescArray =
-			extraUtils.createData(baseClassDescriptorAddress, baseClassDescriptor);
+			extendedFlatAPI.createData(baseClassDescriptorAddress, baseClassDescriptor);
 		if (baseClassDescArray == null) {
 			return null;
 		}
@@ -467,16 +467,16 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 			//TODO: extraUtils.getReferencedAddress(address, getIboIf64bit);
 			Address baseClassDescriptorAddress = getReferencedAddress(address.add(i * 4));
 
-			Data baseClassDescriptor = extraUtils.getDataAt(baseClassDescriptorAddress);
+			Data baseClassDescriptor = extendedFlatAPI.getDataAt(baseClassDescriptorAddress);
 			if (baseClassDescriptor == null || !baseClassDescriptor.getDataType()
 					.getName()
 					.equals(
 						RTTI_BASE_CLASS_DESCRIPTOR_DATA_NAME)) {
 
-				int num1 = extraUtils.getInt(baseClassDescriptorAddress.add(8));
-				int num2 = extraUtils.getInt(baseClassDescriptorAddress.add(12));
-				int num3 = extraUtils.getInt(baseClassDescriptorAddress.add(16));
-				int num4 = extraUtils.getInt(baseClassDescriptorAddress.add(20));
+				int num1 = extendedFlatAPI.getInt(baseClassDescriptorAddress.add(8));
+				int num2 = extendedFlatAPI.getInt(baseClassDescriptorAddress.add(12));
+				int num3 = extendedFlatAPI.getInt(baseClassDescriptorAddress.add(16));
+				int num4 = extendedFlatAPI.getInt(baseClassDescriptorAddress.add(20));
 
 				baseClassDescriptor = createBaseClassDescriptor(baseClassDescriptorAddress);
 				if (baseClassDescriptor != null) {
@@ -556,7 +556,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 		//TODO: extraUtils.getReferencedAddress(address, getIboIf64bit);
 		Address classHierarchyDescriptorAddress = getReferencedAddress(address);
 
-		Data classHierarchyStructure = extraUtils.getDataAt(classHierarchyDescriptorAddress);
+		Data classHierarchyStructure = extendedFlatAPI.getDataAt(classHierarchyDescriptorAddress);
 
 		if (classHierarchyStructure != null &&
 			classHierarchyStructure.getDataType()
@@ -601,7 +601,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 			classHierarchyDescriptorAddress.add(sizeOfDt));
 
 		Data classHierarchyStructure =
-			extraUtils.createData(classHierarchyDescriptorAddress, classHDatatype);
+			extendedFlatAPI.createData(classHierarchyDescriptorAddress, classHDatatype);
 		if (classHierarchyStructure == null) {
 			return null;
 		}
@@ -634,13 +634,13 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 				symbolTable.getPrimarySymbol(classHierarchyDescriptorAddress);
 			Namespace classNamespace = classHierarchyDescriptorSymbol.getParentNamespace();
 
-			int numBaseClasses = extraUtils.getInt(classHierarchyDescriptorAddress.add(8));
+			int numBaseClasses = extendedFlatAPI.getInt(classHierarchyDescriptorAddress.add(8));
 
 			//TODO: extraUtils.getReferencedAddress(address, getIboIf64bit);
 			Address baseClassArrayAddress =
 				getReferencedAddress(classHierarchyDescriptorAddress.add(12));
 
-			Data baseClassDescArray = extraUtils.getDataAt(baseClassArrayAddress);
+			Data baseClassDescArray = extendedFlatAPI.getDataAt(baseClassArrayAddress);
 
 			if (baseClassDescArray != null && baseClassDescArray.isArray()) {
 				baseClassArrayAddresses.add(baseClassArrayAddress);
@@ -704,7 +704,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 		api.clearListing(baseClassArrayAddress,
 			baseClassArrayAddress.add(numBaseClasses * sizeOfDt));
 		Data baseClassDescArray =
-			extraUtils.createData(baseClassArrayAddress, baseClassDescArrayDT);
+			extendedFlatAPI.createData(baseClassArrayAddress, baseClassDescArrayDT);
 
 		if (baseClassDescArray == null) {
 			return null;
@@ -740,7 +740,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 				continue;
 			}
 
-			Reference[] referencesTo = extraUtils.getReferencesTo(completeObjectLocatorAddress);
+			Reference[] referencesTo = extendedFlatAPI.getReferencesTo(completeObjectLocatorAddress);
 			if (referencesTo.length == 0) {
 				//println("no refs to " + completeObjectLocatorAddress.toString());
 				continue;
@@ -824,7 +824,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 		// this will work whether there is a created reference or not
 		int addressSize = address.getSize();
 		if (addressSize == 32) {
-			long offset = extraUtils.getInt(address);
+			long offset = extendedFlatAPI.getInt(address);
 
 			return address.getNewAddress(offset);
 		}
@@ -832,7 +832,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 		// this currently will workn only if there is a created reference
 		// TODO: get ibo bytes and figure out what the ibo ref address would be
 		if (addressSize == 64) {
-			Reference refs[] = extraUtils.getReferencesFrom(address);
+			Reference refs[] = extendedFlatAPI.getReferencesFrom(address);
 			if (refs.length == 0) {
 				return null;
 			}
@@ -875,7 +875,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 			findVftableReferencesNotInFunction(vftableSymbols);
 
 		if (unusedVftableReferences.size() > 0) {
-			extraUtils.createUndefinedFunctions(unusedVftableReferences);
+			extendedFlatAPI.createUndefinedFunctions(unusedVftableReferences);
 		}
 
 		// create these automatically if found
@@ -937,7 +937,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 				// Create Data Type Manager Category for given class
 				// TODO: make this global and check it for null
 				CategoryPath classPath =
-					extraUtils.createDataTypeCategoryPath(classDataTypesCategoryPath,
+					extendedFlatAPI.createDataTypeCategoryPath(classDataTypesCategoryPath,
 						classNameWithNamespace);
 
 				RecoveredClass nonVftableClass =
@@ -982,7 +982,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 	 */
 	private List<Symbol> getListOfClassHierarchyDescriptors() throws CancelledException {
 
-		List<Symbol> classHierarchyDescriptorList = extraUtils.getListOfSymbolsInAddressSet(
+		List<Symbol> classHierarchyDescriptorList = extendedFlatAPI.getListOfSymbolsInAddressSet(
 			getInitializedMemory(), RTTI_CLASS_HIERARCHY_DESCRIPTOR_LABEL, false);
 
 		return classHierarchyDescriptorList;
@@ -1011,13 +1011,13 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 				Address vftableAddress = vftableIterator.next();
 				Address ptrToColAddress = vftableAddress.subtract(defaultPointerSize);
 
-				Data pointerToCompleteObjLocator = extraUtils.getDataAt(vftableAddress);
+				Data pointerToCompleteObjLocator = extendedFlatAPI.getDataAt(vftableAddress);
 				if (pointerToCompleteObjLocator == null) {
 					pointerToCompleteObjLocator =
-						extraUtils.createData(ptrToColAddress, pointerDataType);
+						extendedFlatAPI.createData(ptrToColAddress, pointerDataType);
 				}
 
-				Address colAddress = extraUtils.getReferencedAddress(ptrToColAddress, false);
+				Address colAddress = extendedFlatAPI.getReferencedAddress(ptrToColAddress, false);
 
 				if (colAddress == null) {
 //					println(recoveredClass.getName() + " couldn't get referenced col from " +
@@ -1028,7 +1028,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 				try {
 					Address addressOfOffset = colAddress.add(4);
 
-					int offset = extraUtils.getInt(addressOfOffset);
+					int offset = extendedFlatAPI.getInt(addressOfOffset);
 
 					recoveredClass.addClassOffsetToVftableMapping(offset, vftableAddress);
 				}
@@ -1178,7 +1178,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 
 		List<RecoveredClass> classHierarchy = new ArrayList<RecoveredClass>();
 
-		List<Symbol> symbols = extraUtils.getListOfSymbolsByNameInNamespace(
+		List<Symbol> symbols = extendedFlatAPI.getListOfSymbolsByNameInNamespace(
 			RTTI_BASE_CLASS_ARRAY_LABEL,
 			recoveredClass.getClassNamespace(), false);
 
@@ -1195,7 +1195,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 				Address pointerAddress = rttiBaseClassDescriptorArray.getComponent(i).getAddress();
 
 				Address baseClassDescriptorAddress =
-					extraUtils.getSingleReferencedAddress(pointerAddress);
+					extendedFlatAPI.getSingleReferencedAddress(pointerAddress);
 
 				if (baseClassDescriptorAddress == null) {
 					return classHierarchy;
@@ -1246,13 +1246,13 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 	private int getClassInheritanceFlag(Namespace classNamespace)
 			throws CancelledException, MemoryAccessException, AddressOutOfBoundsException {
 
-		List<Symbol> symbols = extraUtils.getListOfSymbolsByNameInNamespace(
+		List<Symbol> symbols = extendedFlatAPI.getListOfSymbolsByNameInNamespace(
 			RTTI_CLASS_HIERARCHY_DESCRIPTOR_LABEL, classNamespace, false);
 
 		if (symbols.size() >= 1) {
 
 			try {
-				return (extraUtils.getInt(symbols.get(0).getAddress().add(4)));
+				return (extendedFlatAPI.getInt(symbols.get(0).getAddress().add(4)));
 			}
 			catch (MemoryAccessException e) {
 //				println("Could not get class inheritance flag at address " +
@@ -1393,7 +1393,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 
 			// iterate over base class array and for each parent class of the given recovered class 
 			// get the mdisp, pdisp, vdisp info
-			List<Symbol> baseClassArray = extraUtils.getListOfSymbolsByNameInNamespace(
+			List<Symbol> baseClassArray = extendedFlatAPI.getListOfSymbolsByNameInNamespace(
 				RTTI_BASE_CLASS_ARRAY_LABEL, recoveredClass.getClassNamespace(), false);
 
 			// this should never happen
@@ -1425,7 +1425,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 				Address pointerAddress = baseClassArrayData.getComponent(i).getAddress();
 
 				Address baseClassDescriptorAddress =
-					extraUtils.getReferencedAddress(pointerAddress, true);
+					extendedFlatAPI.getReferencedAddress(pointerAddress, true);
 				if (baseClassArrayAddress == null) {
 					continue;
 				}
@@ -1630,7 +1630,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 						getTargetAddressFromPcodeOp(offsetPcodeOpPair.getPcodeOp());
 
 					Address vbtableAddress =
-						extraUtils.getSingleReferencedAddress(listingAddress);
+						extendedFlatAPI.getSingleReferencedAddress(listingAddress);
 
 					if (vbtableAddress == null) {
 						continue;
@@ -1989,7 +1989,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 				if (possibleVftable == null) {
 
 					Function referencedFunction =
-						extraUtils.getReferencedFunction(classReferenceAddress, true);
+						extendedFlatAPI.getReferencedFunction(classReferenceAddress, true);
 					if (referencedFunction == null) {
 						continue;
 					}
@@ -2337,7 +2337,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 			Address pointerAddress = baseClassArrayData.getComponent(i).getAddress();
 
 			Address baseClassDescriptorAddress =
-				extraUtils.getReferencedAddress(pointerAddress, true);
+				extendedFlatAPI.getReferencedAddress(pointerAddress, true);
 			if (baseClassDescriptorAddress == null) {
 				continue;
 			}
@@ -2400,7 +2400,8 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 						dataLength = baseClassStructure.getLength() - lengthOfVirtualParent;
 					}
 
-					if (structUtils.canAdd(classStructureDataType, baseClassOffset, dataLength,
+					if (EditStructureUtils.canAdd(classStructureDataType, baseClassOffset,
+						dataLength,
 						monitor)) {
 						classStructureDataType =
 							addIndividualComponentsToStructure(classStructureDataType,
@@ -2410,10 +2411,11 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 				}
 
 				// else copy whole baseClass structure to the class Structure
-				if (structUtils.canAdd(classStructureDataType, baseClassOffset,
+				if (EditStructureUtils.canAdd(classStructureDataType, baseClassOffset,
 					baseClassStructure.getLength(), monitor)) {
 					classStructureDataType =
-						structUtils.addDataTypeToStructure(classStructureDataType, baseClassOffset,
+						EditStructureUtils.addDataTypeToStructure(classStructureDataType,
+							baseClassOffset,
 							baseClassStructure, baseClassStructure.getName(), monitor);
 
 				}
@@ -2429,11 +2431,12 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 
 				baseClassOffset = api.getInt(recoveredClass.getVbtableAddress().add(vdisp)) + pdisp;
 
-				if (structUtils.canAdd(classStructureDataType, baseClassOffset,
+				if (EditStructureUtils.canAdd(classStructureDataType, baseClassOffset,
 					baseClassStructure.getLength(), monitor)) {
 
 					classStructureDataType =
-						structUtils.addDataTypeToStructure(classStructureDataType, baseClassOffset,
+						EditStructureUtils.addDataTypeToStructure(classStructureDataType,
+							baseClassOffset,
 							baseClassStructure, baseClassStructure.getName(), monitor);
 
 				}
@@ -2461,9 +2464,10 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 
 			DataType classVftablePointer = vfPointerDataTypes.get(vftableAddress);
 
-			if (structUtils.canAdd(classStructureDataType, offset.intValue(),
+			if (EditStructureUtils.canAdd(classStructureDataType, offset.intValue(),
 				classVftablePointer.getLength(), monitor)) {
-				classStructureDataType = structUtils.addDataTypeToStructure(classStructureDataType,
+				classStructureDataType = EditStructureUtils.addDataTypeToStructure(
+					classStructureDataType,
 					offset.intValue(), classVftablePointer, CLASS_VTABLE_PTR_FIELD_EXT, monitor);
 
 			}
@@ -2479,7 +2483,8 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 		int dataOffset = getDataOffset(recoveredClass, classStructureDataType);
 		int dataLen = UNKNOWN;
 		if (dataOffset != NONE) {
-			dataLen = structUtils.getNumberOfUndefinedsStartingAtOffset(classStructureDataType,
+			dataLen =
+				EditStructureUtils.getNumberOfUndefinedsStartingAtOffset(classStructureDataType,
 				dataOffset, monitor);
 		}
 
@@ -2489,7 +2494,8 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 				classStructureDataType, dataLen, dataOffset);
 
 			if (recoveredClassDataStruct != null) {
-				classStructureDataType = structUtils.addDataTypeToStructure(classStructureDataType,
+				classStructureDataType =
+					EditStructureUtils.addDataTypeToStructure(classStructureDataType,
 					dataOffset, recoveredClassDataStruct,
 					classStructureDataType.getName() + "_data", monitor);
 			}
@@ -2556,11 +2562,12 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 				monitor.checkCanceled();
 
 				// if enough empty bytes - add class vftable pointer
-				if (structUtils.canAdd(classStructureDataType, vftableOffset,
+				if (EditStructureUtils.canAdd(classStructureDataType, vftableOffset,
 					classVftablePointer.getLength(), monitor)) {
 
 					classStructureDataType =
-						structUtils.addDataTypeToStructure(classStructureDataType, vftableOffset,
+						EditStructureUtils.addDataTypeToStructure(classStructureDataType,
+							vftableOffset,
 							classVftablePointer, CLASS_VTABLE_PTR_FIELD_EXT, monitor);
 
 					addedVftablePointer = true;
@@ -2677,7 +2684,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 			return false;
 		}
 		int numUndefined1s =
-			structUtils.getNumberOfUndefinedsStartingAtOffset(structure, 0, monitor);
+			EditStructureUtils.getNumberOfUndefinedsStartingAtOffset(structure, 0, monitor);
 		if (structure.getLength() == numUndefined1s) {
 			return true;
 		}
@@ -2722,7 +2729,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 			Address pointerAddress = baseClassArrayData.getComponent(i).getAddress();
 
 			Address baseClassDescriptorAddress =
-				extraUtils.getReferencedAddress(pointerAddress, true);
+				extendedFlatAPI.getReferencedAddress(pointerAddress, true);
 			if (baseClassDescriptorAddress == null) {
 				continue;
 			}
@@ -2785,7 +2792,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 	 */
 	private Data getBaseClassArray(RecoveredClass recoveredClass) throws CancelledException {
 
-		List<Symbol> baseClassArray = extraUtils.getListOfSymbolsByNameInNamespace(
+		List<Symbol> baseClassArray = extendedFlatAPI.getListOfSymbolsByNameInNamespace(
 			RTTI_BASE_CLASS_ARRAY_LABEL, recoveredClass.getClassNamespace(), false);
 
 		if (baseClassArray.size() != 1) {
@@ -2842,9 +2849,11 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
 			DataType vbaseStructPointer = dataTypeManager.getPointer(vbtableStructure);
 
 			int dataLength = vbaseStructPointer.getLength();
-			if (structUtils.canAdd(classStructureDataType, vbtableOffset, dataLength, monitor)) {
+			if (EditStructureUtils.canAdd(classStructureDataType, vbtableOffset, dataLength,
+				monitor)) {
 
-				classStructureDataType = structUtils.addDataTypeToStructure(classStructureDataType,
+				classStructureDataType =
+					EditStructureUtils.addDataTypeToStructure(classStructureDataType,
 					vbtableOffset, vbaseStructPointer, "vbtablePtr", monitor);
 
 			}

Ghidra/Features/Decompiler/ghidra_scripts/classrecovery/RecoveredClass.java

@@ -95,7 +95,6 @@ public class RecoveredClass {
 	private static final int NONE = -1;
 
 	TaskMonitor monitor = TaskMonitor.DUMMY;
-	EditStructureUtils structUtils;
 
 
 	RecoveredClass(String name, CategoryPath classPath, Namespace classNamespace,
@@ -105,7 +104,6 @@ public class RecoveredClass {
 		this.classNamespace = classNamespace;
 		this.dataTypeManager = dataTypeManager;
 
-		this.structUtils = new EditStructureUtils();
 	}
 
 	public String getName() {
@@ -531,11 +529,11 @@ public class RecoveredClass {
 			// if the new component is a non-empty structure, check to see if the current
 			// structure has undefined or equivalent components and replace with new struct if so
 			if (newComponentDataType instanceof Structure) {
-				if (structUtils.hasReplaceableComponentsAtOffset(computedClassStructure,
+				if (EditStructureUtils.hasReplaceableComponentsAtOffset(computedClassStructure,
 					offset, (Structure) newComponentDataType, monitor)) {
 
 					boolean successfulClear =
-						structUtils.clearLengthAtOffset(computedClassStructure, offset,
+						EditStructureUtils.clearLengthAtOffset(computedClassStructure, offset,
 							length, monitor);
 
 					if (successfulClear) {
@@ -547,13 +545,14 @@ public class RecoveredClass {
 			}
 
 			// if current component is undefined size 1 and new component is not undefined size 1
-			// then replace it
-			if (structUtils.isUndefined1(currentComponentDataType) &&
-				!structUtils.isUndefined1(newComponentDataType)) {
-				if (structUtils.hasEnoughUndefinedsOfAnyLengthAtOffset(computedClassStructure,
+			// and there are enough undefineds for it to fit, then replace it
+			if (EditStructureUtils.isUndefined1(currentComponentDataType) &&
+				!EditStructureUtils.isUndefined1(newComponentDataType)) {
+				if (EditStructureUtils.hasEnoughUndefinedsOfAnyLengthAtOffset(
+					computedClassStructure,
 					offset, length, monitor)) {
 					boolean successfulClear =
-						structUtils.clearLengthAtOffset(computedClassStructure, offset,
+						EditStructureUtils.clearLengthAtOffset(computedClassStructure, offset,
 							length, monitor);
 
 					if (successfulClear) {
@@ -567,13 +566,14 @@ public class RecoveredClass {
 			// if new component is not an undefined data type and the current componenent(s)
 			// that make up new component length are all undefineds then clear and replace
 			// the current component(s) with the new one
-			if (structUtils.isUndefined(currentComponentDataType) &&
-				!structUtils.isUndefined(newComponentDataType)) {
+			if (Undefined.isUndefined(currentComponentDataType) &&
+				!Undefined.isUndefined(newComponentDataType)) {
 
-				if (structUtils.hasEnoughUndefinedsOfAnyLengthAtOffset(computedClassStructure,
+				if (EditStructureUtils.hasEnoughUndefinedsOfAnyLengthAtOffset(
+					computedClassStructure,
 					offset, length, monitor)) {
 					boolean successfulClear =
-						structUtils.clearLengthAtOffset(computedClassStructure, offset,
+						EditStructureUtils.clearLengthAtOffset(computedClassStructure, offset,
 							length, monitor);
 
 					if (successfulClear) {
@@ -601,7 +601,7 @@ public class RecoveredClass {
 				continue;
 			}
 
-			if (structUtils.isUndefined1(dataType)) {
+			if (EditStructureUtils.isUndefined1(dataType)) {
 				dataType = new Undefined1DataType();
 				DataTypeComponent component =
 					computedClassStructure.getComponentAt(offset.intValue());