Changes related to display as/type toggling.

Author: fuzyll

binaryninjaapi.h

@@ -11217,6 +11217,7 @@ namespace BinaryNinja {
 		Confidence<bool> IsConst() const;
 		Confidence<bool> IsVolatile() const;
 		bool IsSystemCall() const;
+		BNIntegerDisplayType GetIntegerTypeDisplayType() const;
 		void SetIntegerTypeDisplayType(BNIntegerDisplayType displayType);
 
 		Confidence<Ref<Type>> GetChildType() const;

binaryninjacore.h

@@ -1097,6 +1097,8 @@ extern "C"
 		DoubleDisplayType,
 		EnumerationDisplayType,
 		InvertedCharacterConstantDisplayType,
+		UnsignedComplementDecimalDisplayType,
+		UnsignedComplementHexadecimalDisplayType,
 	};
 
 	BN_ENUM(uint8_t, BNFlowGraphOption)

docs/guide/migration/migrationguideida.md

@@ -44,6 +44,7 @@ Some major exceptions are:
     - `T` for Types
     - `H` to toggle to/from Hex View
     - `[TAB]` to toggle to/from disassembly
+- `0` toggles integer display between hexadecimal and decimal, which is `H` in IDA
 
 ## Cross-References
 

docs/guide/types/basictypes.md

@@ -112,7 +112,7 @@ the name of a type will take you to its definition.
 	* **Type > Make 16-bit Integer** - Create `uint16_t` members in selection
 	* **Type > Make 32-bit Integer** - Create `uint32_t` members in selection
 	* **Type > Make 64-bit Integer** - Create `uint64_t` members in selection
-	* **Type > Invert Integer Sign** - Toggle integer signedness, e.g. between `uint8_t` and `int8_t`
+	* **Type > Toggle Integer Signedness** - Toggle integer signedness, e.g. between `uint8_t` and `int8_t`
 	* **Type > Cycle Integer Size** - Change integer member size in order: `uint8_t`, `uint16_t`, `uint32_t`, `uint64_t`
 	* **Type > Make 32-bit Float** - Create `float` members in selection
 	* **Type > Make 64-bit Float** - Create `double` members in selection

docs/guide/types/type.md

@@ -9,6 +9,8 @@ The simplest way to directly manipulate types in disassembly is by viewing an ex
  - `1`, `2`, `4`, `8`: The number hotkeys will create a data variable at the current location if none exists, and then change the size of the variable to an integer in the size of bytes specified in the hotkey.
  - `d`: If you want to cycle through the different integer sizes, repeatedly pressing `d` has the same effect as pressing the numbers in order.
  - `-`: To quickly toggle integers between signed and unsigned integers, you can use the `-` hotkey.
+ - `0`: To quickly toggle integer display between hexadecimal and decimal, you can use the `0` hotkey.
+ - `~`: To quickly toggle integer display between normal and bitwise complement, you can use the `~` hotkey.
  - `a`: This hotkey sets or creates the current variable to a character array up until and including the next null byte.
  - `o`: `o` will set or create the current variable to be a pointer reference.
  - `*`: If you have a selection of identical variables, `*` will convert them into an array of elements. If you have no selection, the "Create Array" dialog will be shown allowing you to create an array of specific type and count at the current location.

python/function.py

@@ -4181,6 +4181,17 @@ def add_stack_var_reference_tokens(
 	def is_integer_token(token: 'InstructionTextToken') -> bool:
 		return core.BNIsIntegerToken(token.type)
 
+	@staticmethod
+	def get_display_string_for_integer(
+	    binary_view: Optional['binaryview.BinaryView'], display_type: IntegerDisplayType, value: int, input_width: int,
+	    is_signed: bool = True
+	) -> str:
+		if isinstance(display_type, str):
+			display_type = IntegerDisplayType[display_type]
+		return core.BNGetDisplayStringForInteger(
+			binary_view.handle if binary_view is not None else None, display_type, value, input_width, is_signed
+		)
+
 	def add_integer_token(
 	    self, tokens: List['InstructionTextToken'], int_token: 'InstructionTextToken', addr: int,
 	    arch: Optional['architecture.Architecture'] = None

python/types.py

@@ -32,7 +32,7 @@
 	TypeReferenceType, MemberAccess, MemberScope, TypeDefinitionLineType,
 	TokenEscapingType,
 	NameType, PointerSuffix, PointerBaseType,
-	Endianness
+	Endianness, IntegerDisplayType
 )
 from . import callingconvention
 from . import function as _function
@@ -903,6 +903,15 @@ def signed(self, value: BoolWithConfidenceType) -> None:
 		_value = BoolWithConfidence.get_core_struct(value)
 		core.BNTypeBuilderSetSigned(self._handle, _value)
 
+	@property
+	def display_type(self) -> IntegerDisplayType:
+		"""Integer display type for this type."""
+		return core.BNGetIntegerTypeDisplayType(self.immutable_copy().handle)
+
+	@display_type.setter
+	def display_type(self, value: IntegerDisplayType) -> None:
+		core.BNSetIntegerTypeDisplayType(self._handle, value)
+
 	@property
 	def children(self) -> List['TypeBuilder']:
 		return []
@@ -2145,6 +2154,11 @@ def attributes(self) -> Dict[str, str]:
 		core.BNFreeTypeAttributeList(attributes, count.value)
 		return result
 
+	@property
+	def display_type(self) -> IntegerDisplayType:
+		"""Integer display type for this type."""
+		return core.BNGetIntegerTypeDisplayType(self._handle)
+
 	def _to_core_struct(self) -> core.BNTypeWithConfidence:
 		type_conf = core.BNTypeWithConfidence()
 		type_conf.type = self._handle

rust/src/types.rs

@@ -171,6 +171,11 @@ impl TypeBuilder {
         self
     }
 
+    pub fn set_integer_display_type(&self, display_type: IntegerDisplayType) -> &Self {
+        unsafe { BNSetIntegerTypeDisplayType(self.handle, display_type) };
+        self
+    }
+
     // Readable properties
 
     pub fn type_class(&self) -> TypeClass {
@@ -189,6 +194,10 @@ impl TypeBuilder {
         unsafe { BNIsTypeBuilderSigned(self.handle).into() }
     }
 
+    pub fn integer_display_type(&self) -> IntegerDisplayType {
+        self.finalize().integer_display_type()
+    }
+
     pub fn is_const(&self) -> Conf<bool> {
         unsafe { BNIsTypeBuilderConst(self.handle).into() }
     }
@@ -689,6 +698,10 @@ impl Type {
         unsafe { BNIsTypeSigned(self.handle).into() }
     }
 
+    pub fn integer_display_type(&self) -> IntegerDisplayType {
+        unsafe { BNGetIntegerTypeDisplayType(self.handle) }
+    }
+
     pub fn is_const(&self) -> Conf<bool> {
         unsafe { BNIsTypeConst(self.handle).into() }
     }

type.cpp

@@ -1598,6 +1598,15 @@ Confidence<bool> TypeBuilder::IsVolatile() const
 }
 
 
+BNIntegerDisplayType TypeBuilder::GetIntegerTypeDisplayType() const
+{
+	BNType* type = BNFinalizeTypeBuilder(m_object);
+	BNIntegerDisplayType result = BNGetIntegerTypeDisplayType(type);
+	BNFreeType(type);
+	return result;
+}
+
+
 void TypeBuilder::SetIntegerTypeDisplayType(BNIntegerDisplayType displayType)
 {
 	BNSetIntegerTypeDisplayType(m_object, displayType);
@@ -3442,4 +3451,3 @@ fmt::format_context::iterator fmt::formatter<BinaryNinja::Type>::format(
 		return fmt::format_to(ctx.out(), "{}{}", obj.GetStringBeforeName(), obj.GetStringAfterName());
 	}
 }
-

ui/linearview.h

@@ -399,6 +399,7 @@ private Q_SLOTS:
 	void makeString(size_t charSize = 1);
 	void changeType(const UIActionContext& context);
 	void undefineInRange();
+	BNIntegerDisplayType getCurrentDisplayAs(const UIActionContext& context) override;
 	void displayAs(const UIActionContext& context, BNIntegerDisplayType displayType) override;
 	void createStructOrInferStructureType();
 	bool autoCreateArray();