Package ghidra.program.util
Class ProgramMerge
- java.lang.Object
-
- ghidra.program.util.ProgramMerge
-
- All Implemented Interfaces:
PropertyVisitor
public class ProgramMerge extends java.lang.Object implements PropertyVisitor
ProgramMerge
is a class for merging the differences between two programs. The differences are merged from program2 into program1.Program1 is the program being modified by the merge. Program2 is source for obtaining differences to apply to program1.
If name conflicts occur while merging, the item (for example, symbol) will be merged with a new name that consists of the original name followed by "_conflict" and a one up number.
-
-
Field Summary
Fields Modifier and Type Field Description static java.lang.String
SYMBOL_CONFLICT_SUFFIX
Suffix that is attached to a symbol name and then followed by a number to create a new unique symbol name.
-
Constructor Summary
Constructors Constructor Description ProgramMerge(Program resultProgram, Program originProgram)
ProgramMerge
allows the merging of differences from program2 into program1 (the result program).ProgramMerge(AddressTranslator originToResultTranslator)
ProgramMerge
allows the merging of differences from program2 (the origin program) into program1 (the result program).
-
Method Summary
All Methods Static Methods Instance Methods Concrete Methods Modifier and Type Method Description Reference
addReference(Reference originRef, long toSymbolID, boolean replaceExtLoc)
addReference
creates a reference in program1 that is equivalent to the one specified as a parameter.void
applyFunctionTagChanges(AddressSetView originAddressSet, int setting, java.util.Set<FunctionTag> discardTags, java.util.Set<FunctionTag> keepTags, TaskMonitor monitor)
Merges/replaces tags of program2 into program1.void
clearErrorMessage()
This method clears the current error message.void
clearInfoMessage()
This method clears the current informational message.java.lang.String
getErrorMessage()
Get the error messages that resulted from the last call to a merge or replace method.java.lang.String
getInfoMessage()
Get the information messages that resulted from the last call to a merge or replace method.Program
getOriginProgram()
Gets the origin program.Program
getResultProgram()
Gets the result program.static java.lang.String
getUniqueName(SymbolTable symbolTable, java.lang.String name, Address address, Namespace namespace1, Namespace namespace2, SymbolType type)
Create a name that is unique in both namespaces of the given symbolTable.static java.lang.String
getUniqueName(SymbolTable symbolTable, java.lang.String name, Address address, Namespace namespace, SymbolType type)
Create a name that is unique in the indicated namespace of the symbol table.boolean
hasErrorMessage()
Determines if this ProgramMerge currently has an error message.boolean
hasInfoMessage()
Determines if this ProgramMerge currently has an informational message.void
mergeBookmark(Address originAddress, java.lang.String type, java.lang.String category, TaskMonitor monitor)
mergeBookmark
merges the indicated bookmark from the origin program into the result program at an address equivalent to the originAddress.void
mergeBytes(AddressSetView originAddressSet, boolean overwriteInstructions, TaskMonitor monitor)
mergeBytes
merges byte differences within the specified address set.void
mergeCodeUnits(AddressSetView originAddressSet, AddressSetView byteDiffs, boolean mergeDataBytes, TaskMonitor monitor)
mergeCodeUnits
merges all instructions and/or data (as indicated) in the specified address set from the origin program.void
mergeComment(AddressSet originAddressSet, int type, boolean both, TaskMonitor monitor)
mergeComment
merges/replaces comments of the indicated type wherever they occur in the specified address set.void
mergeComments(int commentType, Address originAddress)
mergeComments
merges the comment of the indicated type in program1 with the comment in program2 at the specified address.void
mergeCommentType(AddressSetView originAddressSet, int type, int setting, TaskMonitor monitor)
mergeCommentType
merges/replaces comments of the indicated type wherever they occur in the specified address set.void
mergeEquate(Address originAddress, int opIndex, long value)
mergeEquate
replaces the current equates in program1 with those in program2.void
mergeEquates(AddressSetView originAddressSet, TaskMonitor monitor)
mergeEquates
merges the equate differences in the specified address set.Function
mergeFunction(Address entry, TaskMonitor monitor)
mergeFunction
completely replaces any function at the indicated address in program1 with the function, if any, in program2.void
mergeFunctionLocalSize(Address entry2, TaskMonitor monitor)
mergeFunctionLocalSize
replaces the local size of the function in program1 with the local size of the function in program2 at the specified entry point address.void
mergeFunctionName(Address entry2, TaskMonitor monitor)
mergeFunctionName
replaces the name of the function in program1 with the name of the function in program2 at the specified entry point address.void
mergeFunctionReturn(Address entry2)
mergeFunctionReturn
replaces the return type/storage of the function in program1 with the return type/storage of the function in program2 at the specified entry point address.void
mergeFunctionReturnAddressOffset(Address entry2, TaskMonitor monitor)
mergeFunctionReturnAddressOffset
replaces the return address offset of the function in program1 with the return address offset of the function in program2 at the specified entry point address.void
mergeFunctions(AddressSetView addrSet, TaskMonitor monitor)
mergeFunctions
merges function differences within the specified address set.void
mergeFunctionStackPurgeSize(Address entry2, TaskMonitor monitor)
mergeFunctionStackPurgeSize
replaces the stack purge size of the function in program1 with the stack purge size of the function in program2 at the specified entry point address.void
mergeLabels(AddressSetView originAddressSet, int setting, TaskMonitor monitor)
mergeLabels
merges all symbols and aliases in the specified address set from the second program.void
mergeProperties(AddressSetView originAddressSet, TaskMonitor monitor)
mergeProperties
merges user defined property differences within the specified address set.void
mergeReferences(AddressSetView originAddressSet, boolean onlyKeepDefaults, TaskMonitor monitor)
mergeReferences
merges the references in program1 for the specified address set with the references from program2.void
mergeUserProperty(java.lang.String userPropertyName, Address originAddress)
Replaces the user defined properties from the specified origin address in the origin program to the equivalent result address in the result program.void
replaceComment(int commentType, Address originAddress)
replaceComment
replaces the comment of the indicated type in program1 with the comment in program2 at the specified address.Function
replaceExternalFunction(Function toFunction, Function fromFunction, TaskMonitor monitor)
Replaces the external result function with the origin Function.void
replaceFallThroughs(AddressSetView originAddressSet, TaskMonitor monitor)
replaceFallThroughs
replaces all fallthroughs in program1 for the specified address set with those in program2 where they differ.void
replaceFunctionCallingConvention(Address originEntryPoint, TaskMonitor monitor)
replaceFunctionCallingConvention
changes the function calling convention in program1 if it doesn't match the function calling convention in program2 at the specified entry point address.void
replaceFunctionCustomStorageFlag(Address originEntryPoint, TaskMonitor monitor)
replaceFunctionCustomStorageFlag
changes whether the flag is set indicating the function does not return in program1 if it doesn't match the "custom storage" flag in the function in program2 at the specified entry point address.void
replaceFunctionInlineFlag(Address originEntryPoint, TaskMonitor monitor)
replaceFunctionInlineFlag
changes whether the function is inline in program1 if it doesn't match whether the function is inline in program2 at the specified entry point address.void
replaceFunctionNames(AddressSetView originAddressSet, TaskMonitor monitor)
replaceFunctionNames
merges function name and namespace differences within the specified address set.void
replaceFunctionNoReturnFlag(Address originEntryPoint, TaskMonitor monitor)
replaceFunctionNoReturnFlag
changes whether the flag is set indicating the function does not return in program1 if it doesn't match the "does not return" flag in the function in program2 at the specified entry point address.void
replaceFunctionParameterComment(Address originEntryPoint, int ordinal, TaskMonitor monitor)
replaceFunctionParameterComment
replaces the comment of the indicated function parameter in program1 with the comment from the origin program.void
replaceFunctionParameterDataType(Address originEntryPoint, int ordinal, TaskMonitor monitor)
replaceFunctionParameterDataType
replaces the data type of the indicated function parameter in program1 with the data type from the origin program.void
replaceFunctionParameterName(Address originEntryPoint, int ordinal, TaskMonitor monitor)
replaceFunctionParameterName
replaces the name of the indicated function parameter in program1 with the name from the origin program.void
replaceFunctionParameters(Address originEntryPoint, TaskMonitor monitor)
replaceFunctionParameters
replaces the parameters of the function in program1 with the parameters of the function in program2 at the specified entry point address.void
replaceFunctionParameters(Function toFunc, Function fromFunc)
replaceFunctionParameters
replaces the parameters of the function in program1 with the parameters of the function in program2 at the specified entry point address.void
replaceFunctionSignatureSource(Address originEntryPoint, TaskMonitor monitor)
replaceFunctionSignatureSource
changes the result function's signature source to match the origin program's signature source.void
replaceFunctionVarArgs(Address entry2, TaskMonitor monitor)
replaceFunctionVarArgs
changes whether the function has VarArgs in program1 if it doesn't match the use of VarArgs in the function in program2 at the specified entry point address.void
replaceFunctionVariable(Address originEntryPoint, Variable var, TaskMonitor monitor)
replaceFunctionVariable
replaces the name of the indicated function variable in program1 with that from the origin program.void
replaceFunctionVariableComment(Address originEntryPoint, Variable var, TaskMonitor monitor)
replaceFunctionVariableComment
replaces the comment on the indicated function variable in program1 with the comment from the equivalent variable in program2.void
replaceFunctionVariableDataType(Address originEntryPoint, Variable var, TaskMonitor monitor)
replaceFunctionVariableDataType
replaces the data type on the indicated function variable in program1 with the data type from the equivalent variable in program2.void
replaceFunctionVariableName(Address originEntryPoint, Variable var, TaskMonitor monitor)
replaceFunctionVariableName
replaces the name on the indicated function variable in program1 with the name from the equivalent variable in program2.void
replaceLabels(AddressSet originAddressSet, boolean replaceFunction, TaskMonitor monitor)
replaceLabels
replaces all symbols and aliases in the specified address set from the second program.Reference
replaceReference(Reference resultRef, Reference originRef)
Replaces the reference in program1 with the reference from the origin program.Reference
replaceReference(Reference resultRef, Reference originRef, long toSymbolID)
Replaces the reference in program1 with the reference from the origin program.void
replaceReferences(Address originAddress, int operandIndex)
replaceReferences
replaces all references in program1 for the specified address and operand index with those in program2.void
replaceReferences(AddressSetView originAddressSet, boolean onlyKeepDefaults, TaskMonitor monitor)
replaceReferences
replaces all references in program1 for the specified address set with the references from program2.void
replaceReferences(AddressSetView originAddressSet, TaskMonitor monitor)
replaceReferences
replaces all references in program1 for the specified address set with those in program2.void
replaceVariables(Address originEntryPoint, java.util.List<Variable> varList, TaskMonitor monitor)
replaceFunctionVariables
replaces the function variables/parameters in program1 with that from the origin program.void
visit()
Set the property on the merge program's code unit if the named property is a void property type.void
visit(int value)
Set the property on the merge program's code unit if the named property is an int property type.void
visit(Saveable value)
Set the property on the merge program's code unit if the named property is an Object property type.void
visit(java.lang.Object value)
Set the property on the merge program's code unit if the named property is an Object property type.void
visit(java.lang.String value)
Set the property on the merge program's code unit if the named property is a String property type.
-
-
-
Constructor Detail
-
ProgramMerge
public ProgramMerge(Program resultProgram, Program originProgram)
ProgramMerge
allows the merging of differences from program2 into program1 (the result program).- Parameters:
resultProgram
- The result program that will get modified by merge.originProgram
- The program (used as read only) for obtaining differences to merge.
-
ProgramMerge
public ProgramMerge(AddressTranslator originToResultTranslator)
ProgramMerge
allows the merging of differences from program2 (the origin program) into program1 (the result program).
If the address translator is not a "one for one translator" then certain methods within this class will throw an UnsupportedOperationException. The destination program from the address translator should be the result program into which changes are made. The source program from the translator is the origin program for obtaining the changes.- Parameters:
originToResultTranslator
- converts addresses from the origin program into an equivalent address in the destination program.- See Also:
AddressTranslator
-
-
Method Detail
-
getResultProgram
public Program getResultProgram()
Gets the result program. Merge changes are applied to this program.- Returns:
- the program being changed by the merge.
-
getOriginProgram
public Program getOriginProgram()
Gets the origin program. This program is used for obtaining things to merge into program1.- Returns:
- the program we are obtaining the changes from which we will merge.
-
hasErrorMessage
public boolean hasErrorMessage()
Determines if this ProgramMerge currently has an error message.- Returns:
- true if there is an error message.
-
hasInfoMessage
public boolean hasInfoMessage()
Determines if this ProgramMerge currently has an informational message.- Returns:
- true if there is an information message.
-
getErrorMessage
public java.lang.String getErrorMessage()
Get the error messages that resulted from the last call to a merge or replace method. These are errors that prevented something from being merged.
Important: Call clearErrorMessage() to clear the current error message after this returns it.- Returns:
- the error message string or an empty string if there were no problems with the merge.
-
getInfoMessage
public java.lang.String getInfoMessage()
Get the information messages that resulted from the last call to a merge or replace method. These messages are non-critical changes that were necessary during the merge. For example giving a symbol a name with a conflict extension because another symbol with that name existed elsewhere in the program already.
Important: Call clearInfoMessage() to clear the current info message after this returns it.- Returns:
- the information message string or an empty string if there were no informational messages for the merge.
-
clearErrorMessage
public void clearErrorMessage()
This method clears the current error message.
-
clearInfoMessage
public void clearInfoMessage()
This method clears the current informational message.
-
mergeBytes
public void mergeBytes(AddressSetView originAddressSet, boolean overwriteInstructions, TaskMonitor monitor) throws MemoryAccessException, CancelledException, java.lang.UnsupportedOperationException
mergeBytes
merges byte differences within the specified address set.
Note: Any instructions at the equivalent byte addresses in the result program will get cleared and re-created resulting in the existing references being dropped.- Parameters:
originAddressSet
- the addresses to be merged. The addresses in this set are derived from the origin program.overwriteInstructions
- if true affected instructions will be cleared and re-disassmebled after bytes are modifiedmonitor
- the task monitor for notifying the user of this merge's progress.- Throws:
MemoryAccessException
- if bytes can't be merged.CancelledException
- if user cancels via the monitor.java.lang.UnsupportedOperationException
- if the ProgramMerge translator is not a "one for one translator".
-
mergeCodeUnits
public void mergeCodeUnits(AddressSetView originAddressSet, AddressSetView byteDiffs, boolean mergeDataBytes, TaskMonitor monitor) throws MemoryAccessException, CancelledException, java.lang.UnsupportedOperationException
mergeCodeUnits
merges all instructions and/or data (as indicated) in the specified address set from the origin program. It merges them into the result program. When merging instructions, the bytes are also replaced if they differ. This assumes originToResultTranslator maps address spaces and does not do fine-grained mapping of addresses.- Parameters:
originAddressSet
- the addresses to be merged. The addresses in this set should be derived from the origin program.byteDiffs
- address set indicating addresses where the bytes differ between the result program and the origin program. The addresses in this set should be derived from the origin program.mergeDataBytes
- true indicates bytes that differ should be copied when merging Data. false means don't copy any bytes for Data.monitor
- the task monitor for notifying the user of this merge's progress.- Throws:
MemoryAccessException
- if bytes can't be copied.CancelledException
- if user cancels via the monitor.java.lang.UnsupportedOperationException
- if the ProgramMerge translator is not a "one for one translator".
-
mergeEquates
public void mergeEquates(AddressSetView originAddressSet, TaskMonitor monitor) throws CancelledException, java.lang.UnsupportedOperationException
mergeEquates
merges the equate differences in the specified address set.- Parameters:
originAddressSet
- the addresses to be merged. The addresses in this set should be derived from the origin program.monitor
- the task monitor for notifying the user of this merge's progress.- Throws:
CancelledException
- if user cancels via the monitor.java.lang.UnsupportedOperationException
- if the ProgramMerge translators are not "one for one translators".
-
mergeEquate
public void mergeEquate(Address originAddress, int opIndex, long value)
mergeEquate
replaces the current equates in program1 with those in program2.- Parameters:
originAddress
- the address where the equates should be merged. This address should be derived from the origin program.opIndex
- the operand index where the equates should be merged.value
- the scalar value where the equate is used.
-
replaceReferences
public void replaceReferences(AddressSetView originAddressSet, TaskMonitor monitor) throws CancelledException, java.lang.UnsupportedOperationException
replaceReferences
replaces all references in program1 for the specified address set with those in program2. If an equivalent reference already exists then it is updated to match the new reference.
Note: All reference types (memory, stack, external) get replaced where possible. i.e. If a function or variable doesn't exist for a variable reference then it will not be able to replace the reference.- Parameters:
originAddressSet
- the addresses to be merged. The addresses in this set should be derived from the origin program.monitor
- the task monitor for notifying the user of this merge's progress.- Throws:
CancelledException
- if the user cancels the replace via the monitor.java.lang.UnsupportedOperationException
- if the ProgramMerge translators are not "one for one translators".
-
replaceReferences
public void replaceReferences(AddressSetView originAddressSet, boolean onlyKeepDefaults, TaskMonitor monitor) throws CancelledException, java.lang.UnsupportedOperationException
replaceReferences
replaces all references in program1 for the specified address set with the references from program2. If an equivalent reference already exists then it is updated to match the new reference.
Note: All reference types (memory, stack, external) get replaced where possible. i.e. If a function or variable doesn't exist for a variable reference then it will not be able to replace the reference.- Parameters:
originAddressSet
- the addresses to be merged. The addresses in this set should be derived from the origin program.onlyKeepDefaults
- true indicates to replace all references with only the default references from the origin program.monitor
- the task monitor for notifying the user of this merge's progress.- Throws:
CancelledException
- if the user cancels the replace via the monitor.java.lang.UnsupportedOperationException
- if the ProgramMerge translators are not "one for one translators".
-
mergeReferences
public void mergeReferences(AddressSetView originAddressSet, boolean onlyKeepDefaults, TaskMonitor monitor) throws CancelledException, java.lang.UnsupportedOperationException
mergeReferences
merges the references in program1 for the specified address set with the references from program2. If an equivalent reference already exists then it is updated to match the new reference if possible. A merge of references prevents the loss of any non-default references already in the result program.
Important: Fallthrough references will not be merged by this method. Fallthroughs are handled by merging code units.
Note: All reference types (memory, stack, external) get replaced where possible. i.e. If a function or variable doesn't exist for a variable reference then it will not be able to replace the reference.- Parameters:
originAddressSet
- the addresses to be merged. The addresses in this set should be derived from the origin program.onlyKeepDefaults
- true indicates to merge only the default references from the origin program into the result program. Non-default references will not be merged. false indicates merge all references except fallthroughs.monitor
- the task monitor for notifying the user of this merge's progress.- Throws:
CancelledException
- if the user cancels the replace via the monitor.java.lang.UnsupportedOperationException
- if the ProgramMerge translators are not "one for one translators".
-
replaceReferences
public void replaceReferences(Address originAddress, int operandIndex)
replaceReferences
replaces all references in program1 for the specified address and operand index with those in program2. If an equivalent reference already exists then it is updated to match the new reference.
Note: All reference types (memory, stack, external) get replaced where possible. i.e. If a function or variable doesn't exist for a variable reference then it will not be able to replace the reference.- Parameters:
originAddress
- the "from" address where references are to be replacedoperandIndex
- the operand of the code unit at the address where references are to be replaced.
-
replaceReference
public Reference replaceReference(Reference resultRef, Reference originRef)
Replaces the reference in program1 with the reference from the origin program.- Parameters:
resultRef
- the program1 reference to be replaced.originRef
- the program2 reference used to replace what's in program1.- Returns:
- the resulting reference in program1. null if reference is removed by the replace.
-
replaceReference
public Reference replaceReference(Reference resultRef, Reference originRef, long toSymbolID)
Replaces the reference in program1 with the reference from the origin program.- Parameters:
resultRef
- the program1 reference to be replaced.originRef
- the program2 reference used to replace what's in program1.toSymbolID
- ID of the symbol in program1 the resulting reference is to.- Returns:
- the resulting reference in program1. null if reference is removed by the replace.
-
addReference
public Reference addReference(Reference originRef, long toSymbolID, boolean replaceExtLoc)
addReference
creates a reference in program1 that is equivalent to the one specified as a parameter. If a symbol ID is specified, the reference will refer to the symbol in program1 with that ID. If the reference is an external reference, then the external location associated with it can be replaced also by setting the replace external location flag.- Parameters:
originRef
- the reference equivalent to the one to be created.toSymbolID
- ID of the symbol to referred to. null indicates don't refer directly to a symbol.replaceExtLoc
- the replace external location flag. true indicates to replace the external location, if applicable, with the one defined for the reference passed to this method.- Returns:
- the reference that was created. null if none created.
-
replaceFallThroughs
public void replaceFallThroughs(AddressSetView originAddressSet, TaskMonitor monitor) throws CancelledException
replaceFallThroughs
replaces all fallthroughs in program1 for the specified address set with those in program2 where they differ.- Parameters:
originAddressSet
- the addresses to be merged. The addresses in this set should be derived from the origin program.monitor
- the task monitor for notifying the user of this merge's progress.- Throws:
CancelledException
- if the user cancels the replace via the monitor.
-
mergeComment
public void mergeComment(AddressSet originAddressSet, int type, boolean both, TaskMonitor monitor) throws CancelledException
mergeComment
merges/replaces comments of the indicated type wherever they occur in the specified address set.- Parameters:
originAddressSet
- the addresses where comments should be merged/replaced. The addresses in this set should be from the origin program.type
- ProgramMergeFilter comment type. The comment type can be PLATE, PRE, EOL, REPEATABLE, POST.both
- true means merge both program1 and program2 comments. false means replace the program1 comment with the program2 comment.monitor
- the task monitor for notifying the user of this merge's progress.- Throws:
CancelledException
- if user cancels via the monitor.
-
mergeCommentType
public void mergeCommentType(AddressSetView originAddressSet, int type, int setting, TaskMonitor monitor) throws CancelledException
mergeCommentType
merges/replaces comments of the indicated type wherever they occur in the specified address set. It merges them from program2 into program1. This merges eol, pre, post, repeatable, and plate comments.- Parameters:
originAddressSet
- the addresses to be merged. The addresses in this set should be derived from the origin program.type
- the comment type. PLATE, PRE, EOL, REPEATABLE, POSTsetting
- how to merge. IGNORE, REPLACE, MERGEmonitor
- the task monitor for notifying the user of this merge's progress.- Throws:
CancelledException
- if user cancels via the monitor.
-
mergeComments
public void mergeComments(int commentType, Address originAddress)
mergeComments
merges the comment of the indicated type in program1 with the comment in program2 at the specified address.- Parameters:
commentType
- comment type to merge (from CodeUnit class).
EOL_COMMENT, PRE_COMMENT, POST_COMMENT, REPEATABLE_COMMENT, OR PLATE_COMMENT.originAddress
- the address This address should be derived from the origin program.
-
replaceComment
public void replaceComment(int commentType, Address originAddress)
replaceComment
replaces the comment of the indicated type in program1 with the comment in program2 at the specified address.- Parameters:
commentType
- comment type to replace (from CodeUnit class).
EOL_COMMENT, PRE_COMMENT, POST_COMMENT, REPEATABLE_COMMENT, OR PLATE_COMMENT.originAddress
- the address This address should be derived from the origin program.
-
applyFunctionTagChanges
public void applyFunctionTagChanges(AddressSetView originAddressSet, int setting, java.util.Set<FunctionTag> discardTags, java.util.Set<FunctionTag> keepTags, TaskMonitor monitor) throws CancelledException
Merges/replaces tags of program2 into program1. When merging, tags that are in conflict are replaced according to the user setting (ignore, replace, merge).- Parameters:
originAddressSet
- the addresses to be merged.setting
- how to merge. IGNORE, REPLACE, MERGEdiscardTags
- tags to keep out of the final resultkeepTags
- tags to add to the final resultmonitor
- the task monitor for notifying the user of this merge's progress.- Throws:
CancelledException
- if user cancels via the monitor.
-
mergeLabels
public void mergeLabels(AddressSetView originAddressSet, int setting, TaskMonitor monitor) throws CancelledException
mergeLabels
merges all symbols and aliases in the specified address set from the second program. It merges them into the merge program.- Parameters:
originAddressSet
- the addresses to be merged. The addresses in this address set should be derived from program1.setting
- the current label setting.monitor
- the task monitor for notifying the user of this merge's progress.- Throws:
CancelledException
- if user cancels via the monitor.
-
replaceLabels
public void replaceLabels(AddressSet originAddressSet, boolean replaceFunction, TaskMonitor monitor) throws CancelledException
replaceLabels
replaces all symbols and aliases in the specified address set from the second program.- Parameters:
originAddressSet
- the addresses to be replaced The addresses in this address set should be derived from program1.replaceFunction
- true indicates the function symbol should be replacedmonitor
- the task monitor for notifying the user of this merge's progress- Throws:
CancelledException
- if user cancels via the monitor.
-
replaceFunctionNames
public void replaceFunctionNames(AddressSetView originAddressSet, TaskMonitor monitor) throws CancelledException
replaceFunctionNames
merges function name and namespace differences within the specified address set.- Parameters:
originAddressSet
- the addresses to be merged. The addresses in this set should be derived from program1.monitor
- the task monitor for notifying the user of this merge's progress.- Throws:
CancelledException
- if user cancels via the monitor.
-
mergeFunctions
public void mergeFunctions(AddressSetView addrSet, TaskMonitor monitor) throws CancelledException
mergeFunctions
merges function differences within the specified address set.- Parameters:
addrSet
- the addresses to be merged. The addresses in this set should be derived from program1.monitor
- the task monitor for notifying the user of this merge's progress.- Throws:
CancelledException
- if user cancels via the monitor.
-
mergeFunction
public Function mergeFunction(Address entry, TaskMonitor monitor) throws CancelledException
mergeFunction
completely replaces any function at the indicated address in program1 with the function, if any, in program2.- Parameters:
entry
- the entry point address of the function to be merged. This address should be derived from program1.monitor
- the task monitor for notifying the user of this merge's progress.- Throws:
CancelledException
- if user cancels via the monitor.
-
mergeFunctionReturn
public void mergeFunctionReturn(Address entry2)
mergeFunctionReturn
replaces the return type/storage of the function in program1 with the return type/storage of the function in program2 at the specified entry point address.- Parameters:
entry2
- the entry point address of the function. This address should be derived from the origin program.
-
mergeFunctionName
public void mergeFunctionName(Address entry2, TaskMonitor monitor)
mergeFunctionName
replaces the name of the function in program1 with the name of the function in program2 at the specified entry point address.- Parameters:
entry2
- the entry point address of the function. This address should be derived from the origin program.monitor
- the task monitor for notifying the user of this merge's progress.
-
replaceFunctionSignatureSource
public void replaceFunctionSignatureSource(Address originEntryPoint, TaskMonitor monitor)
replaceFunctionSignatureSource
changes the result function's signature source to match the origin program's signature source.- Parameters:
originEntryPoint
- the entry point address of the function. This address should be derived from the origin program.monitor
- the task monitor for notifying the user of this merge's progress.
-
mergeFunctionReturnAddressOffset
public void mergeFunctionReturnAddressOffset(Address entry2, TaskMonitor monitor)
mergeFunctionReturnAddressOffset
replaces the return address offset of the function in program1 with the return address offset of the function in program2 at the specified entry point address.- Parameters:
entry2
- the entry point address of the function. This address should be derived from the origin program.monitor
- the task monitor for notifying the user of this merge's progress.
-
mergeFunctionLocalSize
public void mergeFunctionLocalSize(Address entry2, TaskMonitor monitor)
mergeFunctionLocalSize
replaces the local size of the function in program1 with the local size of the function in program2 at the specified entry point address.- Parameters:
entry2
- the entry point address of the function. This address should be derived from the origin program.monitor
- the task monitor for notifying the user of this merge's progress.
-
mergeFunctionStackPurgeSize
public void mergeFunctionStackPurgeSize(Address entry2, TaskMonitor monitor)
mergeFunctionStackPurgeSize
replaces the stack purge size of the function in program1 with the stack purge size of the function in program2 at the specified entry point address.- Parameters:
entry2
- the entry point address of the function. This address should be derived from the origin program.monitor
- the task monitor for notifying the user of this merge's progress.
-
replaceFunctionVarArgs
public void replaceFunctionVarArgs(Address entry2, TaskMonitor monitor)
replaceFunctionVarArgs
changes whether the function has VarArgs in program1 if it doesn't match the use of VarArgs in the function in program2 at the specified entry point address.- Parameters:
entry2
- the entry point address of the function. This address should be derived from program1.monitor
- the task monitor for notifying the user of this merge's progress.
-
replaceFunctionCallingConvention
public void replaceFunctionCallingConvention(Address originEntryPoint, TaskMonitor monitor)
replaceFunctionCallingConvention
changes the function calling convention in program1 if it doesn't match the function calling convention in program2 at the specified entry point address.- Parameters:
originEntryPoint
- the entry point address of the function. This address should be derived from the origin program.monitor
- the task monitor for notifying the user of this merge's progress.
-
replaceFunctionInlineFlag
public void replaceFunctionInlineFlag(Address originEntryPoint, TaskMonitor monitor)
replaceFunctionInlineFlag
changes whether the function is inline in program1 if it doesn't match whether the function is inline in program2 at the specified entry point address.- Parameters:
originEntryPoint
- the entry point address of the function. This address should be derived from the origin program.monitor
- the task monitor for notifying the user of this merge's progress.
-
replaceFunctionNoReturnFlag
public void replaceFunctionNoReturnFlag(Address originEntryPoint, TaskMonitor monitor)
replaceFunctionNoReturnFlag
changes whether the flag is set indicating the function does not return in program1 if it doesn't match the "does not return" flag in the function in program2 at the specified entry point address.- Parameters:
originEntryPoint
- the entry point address of the function. This address should be derived from the origin program.monitor
- the task monitor for notifying the user of this merge's progress.
-
replaceFunctionCustomStorageFlag
public void replaceFunctionCustomStorageFlag(Address originEntryPoint, TaskMonitor monitor)
replaceFunctionCustomStorageFlag
changes whether the flag is set indicating the function does not return in program1 if it doesn't match the "custom storage" flag in the function in program2 at the specified entry point address.- Parameters:
originEntryPoint
- the entry point address of the function. This address should be derived from the origin program.monitor
- the task monitor for notifying the user of this merge's progress.
-
replaceFunctionParameters
public void replaceFunctionParameters(Address originEntryPoint, TaskMonitor monitor)
replaceFunctionParameters
replaces the parameters of the function in program1 with the parameters of the function in program2 at the specified entry point address. It also replaces the return type/storage as well as custom storage use.- Parameters:
originEntryPoint
- the entry point address of the function. This address should be derived from the origin program.
-
replaceFunctionParameters
public void replaceFunctionParameters(Function toFunc, Function fromFunc)
replaceFunctionParameters
replaces the parameters of the function in program1 with the parameters of the function in program2 at the specified entry point address. It also replaces the return type/storage as well as custom storage use.- Parameters:
toFunc
- target functionfromFunc
- source function
-
getUniqueName
public static java.lang.String getUniqueName(SymbolTable symbolTable, java.lang.String name, Address address, Namespace namespace1, Namespace namespace2, SymbolType type)
Create a name that is unique in both namespaces of the given symbolTable.- Parameters:
symbolTable
- the symbolTable where the symbol will be created.name
- the desired name. This name will be given a conflict suffix if necessary to make it unique.address
- the address of the symbol.namespace1
- the first namespace where the new symbol should be unique. This namespace must be from the same program as the symbol table.namespace2
- the second namespace where the new symbol should be unique. This namespace must be from the same program as the symbol table.type
- the symbol type of the symbol.- Returns:
- a unique name for both namespaces.
-
getUniqueName
public static java.lang.String getUniqueName(SymbolTable symbolTable, java.lang.String name, Address address, Namespace namespace, SymbolType type)
Create a name that is unique in the indicated namespace of the symbol table.- Parameters:
symbolTable
- the symbolTable where the symbol will be created.name
- the desired name. This name will be given a conflict suffix if necessary to make it unique.address
- the address of the symbol.namespace
- the namespace where the new symbol would be created. This namespace must be from the same program as the symbol table.type
- the type of symbol.- Returns:
- a unique name within the namespace.
-
replaceExternalFunction
public Function replaceExternalFunction(Function toFunction, Function fromFunction, TaskMonitor monitor) throws CancelledException, java.lang.UnsupportedOperationException
Replaces the external result function with the origin Function.
Note: This method will replace the function, but does not create the parent namespace or put the function in the parent namespace. This must be done separately.- Parameters:
toFunction
- the result function to replace.fromFunction
- the function to use as the model when replacing the result function.monitor
- the task monitor for notifying the user of this merge's progress.- Returns:
- the new function that was created in the resultListing or null if no function was created. If null is returned you should call getErrorMessage() to see if an error occurred.
- Throws:
CancelledException
- if user cancels via the monitor.java.lang.UnsupportedOperationException
- if the ProgramMerge translators are not "one for one translators".
-
replaceFunctionParameterName
public void replaceFunctionParameterName(Address originEntryPoint, int ordinal, TaskMonitor monitor) throws DuplicateNameException, InvalidInputException
replaceFunctionParameterName
replaces the name of the indicated function parameter in program1 with the name from the origin program.- Parameters:
originEntryPoint
- the entry point address of the function to modify. This address should be derived from the origin program.ordinal
- the index of the parameter to change.monitor
- the task monitor for notifying the user of progress.- Throws:
InvalidInputException
DuplicateNameException
-
replaceFunctionParameterDataType
public void replaceFunctionParameterDataType(Address originEntryPoint, int ordinal, TaskMonitor monitor)
replaceFunctionParameterDataType
replaces the data type of the indicated function parameter in program1 with the data type from the origin program.- Parameters:
originEntryPoint
- the entry point address of the function to modify. This address should be derived from the origin program.ordinal
- the index of the parameter to change.monitor
- the task monitor for notifying the user of progress.
-
replaceFunctionParameterComment
public void replaceFunctionParameterComment(Address originEntryPoint, int ordinal, TaskMonitor monitor)
replaceFunctionParameterComment
replaces the comment of the indicated function parameter in program1 with the comment from the origin program.- Parameters:
originEntryPoint
- the entry point address of the function to modify. This address should be derived from the origin program.ordinal
- the index of the parameter to change.monitor
- the task monitor for notifying the user of progress.
-
replaceFunctionVariable
public void replaceFunctionVariable(Address originEntryPoint, Variable var, TaskMonitor monitor)
replaceFunctionVariable
replaces the name of the indicated function variable in program1 with that from the origin program.- Parameters:
originEntryPoint
- the entry point address of the function to modify. This address should be derived from program1.var
- a variable that is equivalent to the one in program1 to be replaced. The variable passed here could be from another program.monitor
- the task monitor for notifying the user of progress.
-
replaceVariables
public void replaceVariables(Address originEntryPoint, java.util.List<Variable> varList, TaskMonitor monitor) throws CancelledException
replaceFunctionVariables
replaces the function variables/parameters in program1 with that from the origin program.- Parameters:
originEntryPoint
- the entry point address of the function to modify. This address should be derived from program1.varList
- the list of variables to replace.monitor
- the task monitor for notifying the user of progress.- Throws:
CancelledException
- if the user canceled the operation via the task monitor.
-
replaceFunctionVariableName
public void replaceFunctionVariableName(Address originEntryPoint, Variable var, TaskMonitor monitor) throws DuplicateNameException, InvalidInputException
replaceFunctionVariableName
replaces the name on the indicated function variable in program1 with the name from the equivalent variable in program2.- Parameters:
originEntryPoint
- the entry point address of the function to modify. This address should be derived from the origin program.var
- a variable that is equivalent to the one in program1 to be changed. The variable passed here could be from another program.monitor
- the task monitor for notifying the user of progress.- Throws:
InvalidInputException
DuplicateNameException
-
replaceFunctionVariableDataType
public void replaceFunctionVariableDataType(Address originEntryPoint, Variable var, TaskMonitor monitor)
replaceFunctionVariableDataType
replaces the data type on the indicated function variable in program1 with the data type from the equivalent variable in program2.- Parameters:
originEntryPoint
- the entry point address of the function to modify. This address should be derived from the origin program.var
- a variable that is equivalent to the one in program1 to be changed. The variable passed here could be from another program.monitor
- the task monitor for notifying the user of progress.
-
replaceFunctionVariableComment
public void replaceFunctionVariableComment(Address originEntryPoint, Variable var, TaskMonitor monitor)
replaceFunctionVariableComment
replaces the comment on the indicated function variable in program1 with the comment from the equivalent variable in program2.- Parameters:
originEntryPoint
- entry point address of the function whose variable is getting the comment replaced. This address should be derived from the origin program.var
- a variable that is equivalent to the one in program1 to be changed. The variable passed here could be from another program.monitor
- the task monitor for notifying the user of progress.
-
mergeBookmark
public void mergeBookmark(Address originAddress, java.lang.String type, java.lang.String category, TaskMonitor monitor) throws CancelledException
mergeBookmark
merges the indicated bookmark from the origin program into the result program at an address equivalent to the originAddress. Merging means replace any existing bookmark of the specified type for NOTEs or of the specified type and category for non-NOTE types.Note: This method merges a single bookmark without affecting other bookmarks at the indicated address.
- Parameters:
originAddress
- the address in the origin program where the bookmark is to be merged.type
- indicates the type of bookmark to merge.category
- indicates the category of the bookmark.monitor
- a task monitor for providing feedback to the user.- Throws:
CancelledException
- if the user cancels the bookmark merge from the monitor dialog.
-
mergeProperties
public void mergeProperties(AddressSetView originAddressSet, TaskMonitor monitor) throws CancelledException, java.lang.UnsupportedOperationException
mergeProperties
merges user defined property differences within the specified address set.- Parameters:
originAddressSet
- the addresses to be merged from the origin program.monitor
- the task monitor for notifying the user of this merge's progress.- Throws:
CancelledException
- if user cancels via the monitor.java.lang.UnsupportedOperationException
- if the ProgramMerge translator is not a "one for one translator".
-
mergeUserProperty
public void mergeUserProperty(java.lang.String userPropertyName, Address originAddress)
Replaces the user defined properties from the specified origin address in the origin program to the equivalent result address in the result program. Note: To merge properties, there must be a code unit AT the equivalent address in the result program.- Parameters:
originAddress
- the address of the code unit to get the properties from in the origin program.
-
visit
public void visit()
Set the property on the merge program's code unit if the named property is a void property type.- Specified by:
visit
in interfacePropertyVisitor
-
visit
public void visit(java.lang.String value)
Set the property on the merge program's code unit if the named property is a String property type.- Specified by:
visit
in interfacePropertyVisitor
- Parameters:
value
- the value for the named property.
-
visit
public void visit(java.lang.Object value)
Set the property on the merge program's code unit if the named property is an Object property type.- Specified by:
visit
in interfacePropertyVisitor
- Parameters:
value
- the value for the named property.
-
visit
public void visit(Saveable value)
Set the property on the merge program's code unit if the named property is an Object property type.- Specified by:
visit
in interfacePropertyVisitor
- Parameters:
value
- the value for the named property.
-
visit
public void visit(int value)
Set the property on the merge program's code unit if the named property is an int property type.- Specified by:
visit
in interfacePropertyVisitor
- Parameters:
value
- the value for the named property.
-
-