In a Ghidra Java extension how can I achieve what the "Convert" context menu item does in the GUI?

[hippietrail]

In the Ghidra UI there is a "Convert" function on data that lets you change signedness, decimal vs hex, etc:

But I'm writing a Loader extension in Java and I can't seem to find the API that covers this. Where is it located?

(Originally asked on StackExchange)

[sbrptdev2]

You can look at Ghidra/Features/Base/src/test.slow/java/ghidra/app/plugin/core/equate/EquatePlugin1Test.java:754.

The actual source for the plugin is here:

Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/equate

They are just DockingActions. The EquatePlugin1Test externally accesses these as part of a test unit.

[sbrptdev2]

You will need to potentially base your own class off ListingContextAction. I'm not sure if you can extend/inherit from EquatePlugin.

public abstract class AbstractConvertAction extends ListingContextAction {
	protected final EquatePlugin plugin;
	private FontMetrics metrics;
	private final boolean isSigned;	

@dragonmacher (or any other team member) will be able to answer the latter question (if you can use a core plugin's classes from within your own extension). I believe so, but I am not sure about best practices. Technically with Java you can do virtually anything as far as loaded classes are involved.

Again, take inspiration from the test unit plugin.

[dragonmacher]

As mentioned by @sbrptdev2, the actions are created by the EquatePlugin:

		tool.addAction(new ConvertToUnsignedHexAction(this));
		tool.addAction(new ConvertToUnsignedDecimalAction(this));
		tool.addAction(new ConvertToOctalAction(this));
		tool.addAction(new ConvertToSignedHexAction(this));
		tool.addAction(new ConvertToSignedDecimalAction(this));
		tool.addAction(new ConvertToCharAction(this));
		tool.addAction(new ConvertToBinaryAction(this));
		tool.addAction(new ConvertToFloatAction(this));
		tool.addAction(new ConvertToDoubleAction(this));

If you just wish to see how the actions work, then you can just look inside each action. Typically, each action just calls some utility method that you should be able to call from your code. This may be obvious, but if you are writing loader code, then you do not want to create actions, but just use the code that they use, as needed.

[hippietrail]

I'm wondering if I was too vague in my original question. I don't need to access the context menu or the plugin (I think).

In my loader where I figure out the file format I add comments and set datatypes like this:

        listing.createData(addr, ByteDataType.dataType);
        listing.setComment(addr, CodeUnit.EOL_COMMENT, "My signed decimal byte");

And I'm wondering how I can get that byte to display as a signed decimal rather than as the default hex.
I don't usually code in Java so there's a lot I'm missing so apologies if the answers already address this directly and I haven't seen it. I did try to look in the plugin's code to see how it does it but there was too much about parts of Ghidra I don't know yet for me to discover what it does.

I see ConvertToSignedDecimalAction() but this seems to be more closely related to context-menus than datatype. But the method convertToString() seems to be key and it's based on Scalar so I'm guessing there's somehow a way to go through a Listing and get from the datatypes at certain address to these Scalar objects and somehow modify how they are presented as strings as in convertToString() but I can't find the missing links.

[dev747368]

And I'm wondering how I can get that byte to display as a signed decimal rather than as the default hex.

Changing the hex/decimal display settings of a value at an address in your program is pretty simple.

This is a jython snippet you can use as an example:

ghidra.docking.settings.FormatSettingsDefinition.DEF.setChoice(currentProgram.getListing().getDataAt( currentAddress ), ghidra.docking.settings.FormatSettingsDefinition.DECIMAL )

(be sure to put your cursor on a location if you want to use the snippet as-is)

Note, this only changes between hex and decimal display settings. If the underlying data type isn't signed, it probably won't accomplish what you wrote about. In that case, you probably should be using SignedByteDataType.dataType when creating it.

[hippietrail]

Aha thanks. Took me a bit to chase down that I can access this FormatSettingsDefinition from inside a Loader in Java like this:

  FormatSettingsDefinition.DEF.setChoice(data, FormatSettingsDefinition.DECIMAL);

I can't test it since I've forgotten where I needed it while down the Sleigh rabbithole but I have the snippet now when I need it.

[dragonmacher]

There's a bit to unpack in this snippet, but this is how the actions work. My intention was to show the code that the actions use, so you could build what you needed. Inside of ghidra.app.plugin.core.equate.ConvertCommand:

        private String applyEquate(Instruction instruction, int opIndex, int subOpIndex) {
		if (instruction == null || opIndex == -1) {
			return null;
		}

		Scalar scalar = grabMatchingScalar(instruction, opIndex, subOpIndex);
		if (scalar == null) {
			return null;
		}

		String equateName = action.convertToString(program, scalar, false);
		if (equateName.isEmpty()) {
			return null;
		}

		// Check for same named equate with different value.
		EquateTable equateTable = program.getEquateTable();
		Equate eqt = equateTable.getEquate(equateName);
		if (eqt != null && valuesAreDifferent(eqt, scalar)) {
			return "Couldn't convert to " + equateName + ". " + "Equate named " + equateName +
				" already exists with value of " + eqt.getValue() + ".";
		}

		Address address = instruction.getAddress();
		List<Equate> equates = equateTable.getEquates(address, opIndex);

		// First, clear any existing equates with the same value
		for (Equate equate : equates) {
			if (!valuesAreDifferent(equate, scalar)) {
				// Clears matching equates 
				ClearEquateCmd cmd = new ClearEquateCmd(equate.getName(), address, opIndex);
				cmd.applyTo(program);
			}
		}

		// check if default hex scalar format applies
		if (action.getFormatChoice() == FormatSettingsDefinition.HEX) {
			if (scalar.getSignedValue() >= 0 || action.isSignedChoice() == scalar.isSigned()) {
				return null;
			}
		}

		// Then, add the new equate
		SetEquateCmd cmd = new SetEquateCmd(equateName, address, opIndex, scalar.getValue());
		if (!cmd.applyTo(program)) {
			return "Couldn't convert to " + equateName + ". " + cmd.getStatusMsg();
		}

		return null;
	}

The basic flow is to:

• get the scalar in question
• use the select action to decide how to do the conversion
• do some housekeeping
• call the SetEquateCommand

You would need to do something similar, but with much less housekeeping code.

Also, context actions in Ghidra are just a way to plug functionality into the GUI. They are typically backed by a command object that gets run in the background. If you find an action in the GUI that you want to know more about, you can find it in the source code to see what type of command or utility code it is using.