Package ghidra.program.util

Class ProgramMerge

java.lang.Object
ghidra.program.util.ProgramMerge
public class ProgramMerge extends Object
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 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

    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, Set<FunctionTag> discardTags, 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.
    String
    getErrorMessage()
    Get the error messages that resulted from the last call to a merge or replace method.
    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 String
    getUniqueName(SymbolTable symbolTable, String name, Address address, Namespace namespace1, Namespace namespace2, SymbolType type)
    Create a name that is unique in both namespaces of the given symbolTable.
    static String
    getUniqueName(SymbolTable symbolTable, 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, String type, 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(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, List<Variable> varList, TaskMonitor monitor)
    replaceFunctionVariables replaces the function variables/parameters in program1 with that from the origin program.

    Methods inherited from class java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

  • Field Details

    • SYMBOL_CONFLICT_SUFFIX

      public static 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 Details

    • 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:

  • Method Details

    • 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 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 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, 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 modified
      monitor - 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.
      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, 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.
      UnsupportedOperationException - if the ProgramMerge translator is not a "one for one translator".

    • mergeEquates

      public void mergeEquates(AddressSetView originAddressSet, TaskMonitor monitor) throws CancelledException, 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.
      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, 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.
      UnsupportedOperationException - if the ProgramMerge translators are not "one for one translators".

    • replaceReferences

      public void replaceReferences(AddressSetView originAddressSet, boolean onlyKeepDefaults, TaskMonitor monitor) throws CancelledException, 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.
      UnsupportedOperationException - if the ProgramMerge translators are not "one for one translators".

    • mergeReferences

      public void mergeReferences(AddressSetView originAddressSet, boolean onlyKeepDefaults, TaskMonitor monitor) throws CancelledException, 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.
      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 replaced
      operandIndex - 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, POST
      setting - how to merge. IGNORE, REPLACE, MERGE
      monitor - 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, Set<FunctionTag> discardTags, 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, MERGE
      discardTags - tags to keep out of the final result
      keepTags - tags to add to the final result
      monitor - 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 replaced
      monitor - 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 function
      fromFunc - source function

    • getUniqueName

      public static String getUniqueName(SymbolTable symbolTable, 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 String getUniqueName(SymbolTable symbolTable, 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, 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.
      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, 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, String type, 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, 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.
      UnsupportedOperationException - if the ProgramMerge translator is not a "one for one translator".

    • mergeUserProperty

      public void mergeUserProperty(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:
      userPropertyName - original property name
      originAddress - the address of the code unit to get the properties from in the origin program.