Fix a few warnings.

solemnwarning · solemnwarning · commit 059ad1beb66d · 2025-07-25T00:59:32.000+01:00
diff --git a/src/BitEditor.cpp b/src/BitEditor.cpp
@@ -15,8 +15,6 @@
  * Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */
 
-#define __STDC_FORMAT_MACROS
-
 #include "platform.hpp"
 
 #include <inttypes.h>
@@ -297,7 +295,7 @@ void REHex::BitEditor::update()
 	uint64_t old_val = value + 1;
 	try {
 		int num_value_base = get_num_base();
-		old_val = num_value->GetValue<uint64_t>(0, std::numeric_limits<uint64_t>::max(), 0, num_value_base);
+		old_val = num_value->GetNumValue<uint64_t>(0, std::numeric_limits<uint64_t>::max(), 0, num_value_base);
 	}
 	catch(const REHex::NumericTextCtrl::InputError&) {}
 	
@@ -516,7 +514,7 @@ void REHex::BitEditor::OnValueChange(wxCommandEvent &event)
 	
 	uint64_t new_value;
 	try {
-		new_value = num_value->GetValue<uint64_t>(0, max_value, 0, num_value_base);
+		new_value = num_value->GetNumValue<uint64_t>(0, max_value, 0, num_value_base);
 	}
 	catch(const REHex::NumericTextCtrl::InputError &e)
 	{
diff --git a/src/BitmapTool.cpp b/src/BitmapTool.cpp
@@ -75,12 +75,6 @@ enum {
 	ID_BACKGROUND,
 };
 
-/* The minimum interval between updates when rendering the preview bitmap.
- * This only comes into play if the system is heavily loaded - normally we will
- * render chunks at a time in idle events and reset the timer.
-*/
-static const int UPDATE_TIMER_MS = 250;
-
 BEGIN_EVENT_TABLE(REHex::BitmapTool, wxPanel)
 	EVT_CHOICE(ID_COLOUR_DEPTH,  REHex::BitmapTool::OnDepth)
 	EVT_CHOICE(ID_COLOUR_FORMAT, REHex::BitmapTool::OnFormat)
@@ -358,7 +352,7 @@ void REHex::BitmapTool::reset_row_length_spinner()
 void REHex::BitmapTool::update()
 {
 	try {
-		image_offset = offset_textctrl->GetValue<BitOffset>(BitOffset::ZERO);
+		image_offset = offset_textctrl->GetNumValue<BitOffset>(BitOffset::ZERO);
 	}
 	catch(const NumericTextCtrl::InputError&)
 	{
diff --git a/src/ByteRangeSet.cpp b/src/ByteRangeSet.cpp
@@ -25,7 +25,7 @@
 
 #include "ByteRangeSet.hpp"
 
-static const long long INT61_MIN = -0x1000000000000000LL;
+// static const long long INT61_MIN = -0x1000000000000000LL;
 static const long long INT61_MAX = 0xFFFFFFFFFFFFFFFLL;
 
 template<> off_t REHex::RangeSet<off_t>::MAX()
diff --git a/src/FillRangeDialog.cpp b/src/FillRangeDialog.cpp
@@ -1,5 +1,5 @@
 /* Reverse Engineer's Hex Editor
- * Copyright (C) 2020-2024 Daniel Collins <solemnwarning@solemnwarning.net>
+ * Copyright (C) 2020-2025 Daniel Collins <solemnwarning@solemnwarning.net>
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 as published by
@@ -194,10 +194,10 @@ void REHex::FillRangeDialog::OnOK(wxCommandEvent &event)
 	try {
 		if(insert_mode_selected)
 		{
-			selection_off = range_from->GetValue<off_t>(0, doc_length);
+			selection_off = range_from->GetNumValue<off_t>(0, doc_length);
 		}
 		else{
-			selection_off = range_from->GetValue<off_t>(0, (doc_length - 1));
+			selection_off = range_from->GetNumValue<off_t>(0, (doc_length - 1));
 		}
 	}
 	catch(const NumericTextCtrl::InputError &e)
@@ -214,11 +214,11 @@ void REHex::FillRangeDialog::OnOK(wxCommandEvent &event)
 		try {
 			if(insert_mode_selected)
 			{
-				off_t selection_to = range_to->GetValue<off_t>(selection_off);
+				off_t selection_to = range_to->GetNumValue<off_t>(selection_off);
 				selection_length = (selection_to - selection_off) + 1;
 			}
 			else{
-				off_t selection_to = range_to->GetValue<off_t>(selection_off, (doc_length - 1));
+				off_t selection_to = range_to->GetNumValue<off_t>(selection_off, (doc_length - 1));
 				selection_length = (selection_to - selection_off) + 1;
 			}
 		}
@@ -235,10 +235,10 @@ void REHex::FillRangeDialog::OnOK(wxCommandEvent &event)
 		try {
 			if(insert_mode_selected)
 			{
-				selection_length = range_len->GetValue<off_t>(0);
+				selection_length = range_len->GetNumValue<off_t>(0);
 			}
 			else{
-				selection_length = range_len->GetValue<off_t>(0, (doc_length - selection_off));
+				selection_length = range_len->GetNumValue<off_t>(0, (doc_length - selection_off));
 			}
 		}
 		catch(const NumericTextCtrl::InputError &e)
diff --git a/src/NumericEntryDialog.hpp b/src/NumericEntryDialog.hpp
@@ -1,5 +1,5 @@
 /* Reverse Engineer's Hex Editor
- * Copyright (C) 2018-2024 Daniel Collins <solemnwarning@solemnwarning.net>
+ * Copyright (C) 2018-2025 Daniel Collins <solemnwarning@solemnwarning.net>
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 as published by
@@ -195,16 +195,16 @@ namespace REHex {
 				{
 					case BaseHint::AUTO_FORCE:
 					case BaseHint::AUTO:
-						return textbox->GetValue(min_value, max_value, rel_base, 0);
+						return textbox->GetNumValue(min_value, max_value, rel_base, 0);
 						
 					case BaseHint::DEC:
-						return textbox->GetValue(min_value, max_value, rel_base, 10);
+						return textbox->GetNumValue(min_value, max_value, rel_base, 10);
 						
 					case BaseHint::HEX:
-						return textbox->GetValue(min_value, max_value, rel_base, 16);
+						return textbox->GetNumValue(min_value, max_value, rel_base, 16);
 						
 					case BaseHint::OCT:
-						return textbox->GetValue(min_value, max_value, rel_base, 8);
+						return textbox->GetNumValue(min_value, max_value, rel_base, 8);
 				}
 				
 				/* Unreachable. */
diff --git a/src/NumericTextCtrl.hpp b/src/NumericTextCtrl.hpp
@@ -344,15 +344,15 @@ namespace REHex {
 			
 			template<typename T>
 				typename std::enable_if<std::numeric_limits<T>::is_integer, T>::type
-				GetValue(T min = std::numeric_limits<T>::min(), T max = std::numeric_limits<T>::max(), T rel_base = 0, int base = 0)
+				GetNumValue(T min = std::numeric_limits<T>::min(), T max = std::numeric_limits<T>::max(), T rel_base = 0, int base = 0)
 			{
 				std::string sval = wxTextCtrl::GetValue().ToStdString();
 				return ParseValue<T>(sval, min, max, rel_base, base);
 			}
 			
 			template<typename T>
 				typename std::enable_if<std::is_same<T, BitOffset>::value, T>::type
-				GetValue(T min = BitOffset::MIN, T max = BitOffset::MAX, T rel_base = BitOffset::ZERO, int base = 0, bool *bit_explicit = NULL)
+				GetNumValue(T min = BitOffset::MIN, T max = BitOffset::MAX, T rel_base = BitOffset::ZERO, int base = 0, bool *bit_explicit = NULL)
 			{
 				std::string sval = wxTextCtrl::GetValue().ToStdString();
 				return ParseValue<T>(sval, min, max, rel_base, base, bit_explicit);
diff --git a/src/RangeDialog.cpp b/src/RangeDialog.cpp
@@ -1,5 +1,5 @@
 /* Reverse Engineer's Hex Editor
- * Copyright (C) 2019-2024 Daniel Collins <solemnwarning@solemnwarning.net>
+ * Copyright (C) 2019-2025 Daniel Collins <solemnwarning@solemnwarning.net>
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 as published by
@@ -219,7 +219,7 @@ void REHex::RangeDialog::OnOK(wxCommandEvent &event)
 	BitOffset virt_offset;
 	bool virt_offset_bit;
 	try {
-		virt_offset = range_from->GetValue<BitOffset>(BitOffset::MIN, BitOffset::MAX, BitOffset::ZERO, 0, &virt_offset_bit);
+		virt_offset = range_from->GetNumValue<BitOffset>(BitOffset::MIN, BitOffset::MAX, BitOffset::ZERO, 0, &virt_offset_bit);
 	}
 	catch(const NumericTextCtrl::InputError &e)
 	{
@@ -243,7 +243,7 @@ void REHex::RangeDialog::OnOK(wxCommandEvent &event)
 		BitOffset virt_end_incl;
 		bool virt_end_bit;
 		try {
-			virt_end_incl = range_to->GetValue<BitOffset>(BitOffset::MIN, BitOffset::MAX, BitOffset::ZERO, 0, &virt_end_bit);
+			virt_end_incl = range_to->GetNumValue<BitOffset>(BitOffset::MIN, BitOffset::MAX, BitOffset::ZERO, 0, &virt_end_bit);
 		}
 		catch(const NumericTextCtrl::InputError &e)
 		{
@@ -266,7 +266,7 @@ void REHex::RangeDialog::OnOK(wxCommandEvent &event)
 	{
 		BitOffset length;
 		try {
-			length = range_len->GetValue<BitOffset>(BitOffset(0, 1));
+			length = range_len->GetNumValue<BitOffset>(BitOffset(0, 1));
 		}
 		catch(const NumericTextCtrl::InputError &e)
 		{
diff --git a/src/VirtualMappingDialog.cpp b/src/VirtualMappingDialog.cpp
@@ -1,5 +1,5 @@
 /* Reverse Engineer's Hex Editor
- * Copyright (C) 2021 Daniel Collins <solemnwarning@solemnwarning.net>
+ * Copyright (C) 2021-2025 Daniel Collins <solemnwarning@solemnwarning.net>
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 as published by
@@ -184,20 +184,20 @@ off_t REHex::VirtualMappingDialog::get_real_base()
 	off_t min = 0;
 	off_t max = std::max<off_t>(0, (document->buffer_length() - 1));;
 	
-	return real_base_input->GetValue<off_t>(min, max);
+	return real_base_input->GetNumValue<off_t>(min, max);
 }
 
 off_t REHex::VirtualMappingDialog::get_virt_base()
 {
-	return virt_base_input->GetValue<off_t>(0);
+	return virt_base_input->GetNumValue<off_t>(0);
 }
 
 off_t REHex::VirtualMappingDialog::get_segment_length(off_t real_base)
 {
 	off_t min = 1;
 	off_t max = document->buffer_length() - real_base;
 	
-	return segment_length_input->GetValue<off_t>(min, max);
+	return segment_length_input->GetNumValue<off_t>(min, max);
 }
 
 void REHex::VirtualMappingDialog::update_warning()
diff --git a/src/decodepanel.cpp b/src/decodepanel.cpp
@@ -15,8 +15,6 @@
  * Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */
 
-#define __STDC_FORMAT_MACROS
-
 #include "platform.hpp"
 #include <assert.h>
 #include <inttypes.h>
diff --git a/src/document.cpp b/src/document.cpp
@@ -1151,7 +1151,11 @@ int REHex::Document::allocate_highlight_colour(const wxString &label, const wxCo
 	}
 	
 	_tracked_change("change highlight colours",
-		[this, primary_colour, secondary_colour, label, next_highlight_idx]()
+		[this, primary_colour, secondary_colour, label
+			#ifndef NDEBUG
+			, next_highlight_idx
+			#endif
+		]()
 		{
 			auto new_colour_it = highlight_colour_map.add();
 			assert(new_colour_it != highlight_colour_map.end());
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
@@ -1234,7 +1234,7 @@ void REHex::MainWindow::OnExportHex(wxCommandEvent &event)
 		if(((wxTextCtrl*)(start_segment_address))->GetValue() != "")
 		{
 			try {
-				start_segment_address_buf = start_segment_address->GetValue<uint32_t>();
+				start_segment_address_buf = start_segment_address->GetNumValue<uint32_t>();
 			}
 			catch(const NumericTextCtrl::InputError &e)
 			{
@@ -1253,7 +1253,7 @@ void REHex::MainWindow::OnExportHex(wxCommandEvent &event)
 		if(((wxTextCtrl*)(start_linear_address))->GetValue() != "")
 		{
 			try {
-				start_linear_address_buf = start_linear_address->GetValue<uint32_t>();
+				start_linear_address_buf = start_linear_address->GetNumValue<uint32_t>();
 			}
 			catch(const NumericTextCtrl::InputError &e)
 			{
diff --git a/src/search.cpp b/src/search.cpp
@@ -1176,7 +1176,7 @@ void REHex::Search::Value::setup_window_controls(wxWindow *parent, wxSizer *size
 	if(i ## x ## _cb->GetValue()) \
 	{ \
 		try { \
-			uint ## x ## _t v = search_for_tc->GetValue<uint ## x ## _t>(); \
+			uint ## x ## _t v = search_for_tc->GetNumValue<uint ## x ## _t>(); \
 			\
 			if(e_little->GetValue() || e_either->GetValue()) \
 			{ \
@@ -1193,7 +1193,7 @@ void REHex::Search::Value::setup_window_controls(wxWindow *parent, wxSizer *size
 		catch(const REHex::NumericTextCtrl::RangeError &) \
 		{ \
 			try { \
-				int ## x ## _t v = search_for_tc->GetValue<int ## x ## _t>(); \
+				int ## x ## _t v = search_for_tc->GetNumValue<int ## x ## _t>(); \
 				\
 				if(e_little->GetValue() || e_either->GetValue()) \
 				{ \
@@ -1223,13 +1223,13 @@ bool REHex::Search::Value::read_window_controls()
 	if(i8_cb->GetValue())
 	{
 		try {
-			uint8_t v = search_for_tc->GetValue<uint8_t>();
+			uint8_t v = search_for_tc->GetNumValue<uint8_t>();
 			search_for.push_back(std::vector<unsigned char>((unsigned char*)(&(v)), (unsigned char*)(&(v) + 1)));
 		}
 		catch(const REHex::NumericTextCtrl::RangeError &)
 		{
 			try {
-				int8_t v = search_for_tc->GetValue<int8_t>();
+				int8_t v = search_for_tc->GetNumValue<int8_t>();
 				search_for.push_back(std::vector<unsigned char>((unsigned char*)(&(v)), (unsigned char*)(&(v) + 1)));
 			}
 			catch(REHex::NumericTextCtrl::InputError &) {}
@@ -1276,34 +1276,34 @@ void REHex::Search::Value::OnText(wxCommandEvent &event)
 {
 	i8_cb->Disable();
 	
-	try { search_for_tc->GetValue<int8_t>(); i8_cb->Enable(); }
+	try { search_for_tc->GetNumValue<int8_t>(); i8_cb->Enable(); }
 	catch(const REHex::NumericTextCtrl::InputError &) {}
 	
-	try { search_for_tc->GetValue<uint8_t>(); i8_cb->Enable(); }
+	try { search_for_tc->GetNumValue<uint8_t>(); i8_cb->Enable(); }
 	catch(const REHex::NumericTextCtrl::InputError &) {}
 	
 	i16_cb->Disable();
 	
-	try { search_for_tc->GetValue<int16_t>(); i16_cb->Enable(); }
+	try { search_for_tc->GetNumValue<int16_t>(); i16_cb->Enable(); }
 	catch(const REHex::NumericTextCtrl::InputError &) {}
 	
-	try { search_for_tc->GetValue<uint16_t>(); i16_cb->Enable(); }
+	try { search_for_tc->GetNumValue<uint16_t>(); i16_cb->Enable(); }
 	catch(const REHex::NumericTextCtrl::InputError &) {}
 	
 	i32_cb->Disable();
 	
-	try { search_for_tc->GetValue<int32_t>(); i32_cb->Enable(); }
+	try { search_for_tc->GetNumValue<int32_t>(); i32_cb->Enable(); }
 	catch(const REHex::NumericTextCtrl::InputError &) {}
 	
-	try { search_for_tc->GetValue<uint32_t>(); i32_cb->Enable(); }
+	try { search_for_tc->GetNumValue<uint32_t>(); i32_cb->Enable(); }
 	catch(const REHex::NumericTextCtrl::InputError &) {}
 	
 	i64_cb->Disable();
 	
-	try { search_for_tc->GetValue<int64_t>(); i64_cb->Enable(); }
+	try { search_for_tc->GetNumValue<int64_t>(); i64_cb->Enable(); }
 	catch(const REHex::NumericTextCtrl::InputError &) {}
 	
-	try { search_for_tc->GetValue<uint64_t>(); i64_cb->Enable(); }
+	try { search_for_tc->GetNumValue<uint64_t>(); i64_cb->Enable(); }
 	catch(const REHex::NumericTextCtrl::InputError &) {}
 	
 	f32_cb->Disable();

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/* Reverse Engineer's Hex Editor`
`2`		`- * Copyright (C) 2020-2024 Daniel Collins <solemnwarning@solemnwarning.net>`
	`2`	`+ * Copyright (C) 2020-2025 Daniel Collins <solemnwarning@solemnwarning.net>`
`3`	`3`	`*`
`4`	`4`	`* This program is free software; you can redistribute it and/or modify it`
`5`	`5`	`* under the terms of the GNU General Public License version 2 as published by`
`@@ -194,10 +194,10 @@ void REHex::FillRangeDialog::OnOK(wxCommandEvent &event)`
`194`	`194`	`try {`
`195`	`195`	`if(insert_mode_selected)`
`196`	`196`	`{`
`197`		`- selection_off = range_from->GetValue<off_t>(0, doc_length);`
	`197`	`+ selection_off = range_from->GetNumValue<off_t>(0, doc_length);`
`198`	`198`	`}`
`199`	`199`	`else{`
`200`		`- selection_off = range_from->GetValue<off_t>(0, (doc_length - 1));`
	`200`	`+ selection_off = range_from->GetNumValue<off_t>(0, (doc_length - 1));`
`201`	`201`	`}`
`202`	`202`	`}`
`203`	`203`	`catch(const NumericTextCtrl::InputError &e)`
`@@ -214,11 +214,11 @@ void REHex::FillRangeDialog::OnOK(wxCommandEvent &event)`
`214`	`214`	`try {`
`215`	`215`	`if(insert_mode_selected)`
`216`	`216`	`{`
`217`		`- off_t selection_to = range_to->GetValue<off_t>(selection_off);`
	`217`	`+ off_t selection_to = range_to->GetNumValue<off_t>(selection_off);`
`218`	`218`	`selection_length = (selection_to - selection_off) + 1;`
`219`	`219`	`}`
`220`	`220`	`else{`
`221`		`- off_t selection_to = range_to->GetValue<off_t>(selection_off, (doc_length - 1));`
	`221`	`+ off_t selection_to = range_to->GetNumValue<off_t>(selection_off, (doc_length - 1));`
`222`	`222`	`selection_length = (selection_to - selection_off) + 1;`
`223`	`223`	`}`
`224`	`224`	`}`
`@@ -235,10 +235,10 @@ void REHex::FillRangeDialog::OnOK(wxCommandEvent &event)`
`235`	`235`	`try {`
`236`	`236`	`if(insert_mode_selected)`
`237`	`237`	`{`
`238`		`- selection_length = range_len->GetValue<off_t>(0);`
	`238`	`+ selection_length = range_len->GetNumValue<off_t>(0);`
`239`	`239`	`}`
`240`	`240`	`else{`
`241`		`- selection_length = range_len->GetValue<off_t>(0, (doc_length - selection_off));`
	`241`	`+ selection_length = range_len->GetNumValue<off_t>(0, (doc_length - selection_off));`
`242`	`242`	`}`
`243`	`243`	`}`
`244`	`244`	`catch(const NumericTextCtrl::InputError &e)`
Original file line number	Diff line number	Diff line change
`@@ -344,15 +344,15 @@ namespace REHex {`
`344`	`344`
`345`	`345`	`template<typename T>`
`346`	`346`	`typename std::enable_if<std::numeric_limits<T>::is_integer, T>::type`
`347`		`- GetValue(T min = std::numeric_limits<T>::min(), T max = std::numeric_limits<T>::max(), T rel_base = 0, int base = 0)`
	`347`	`+ GetNumValue(T min = std::numeric_limits<T>::min(), T max = std::numeric_limits<T>::max(), T rel_base = 0, int base = 0)`
`348`	`348`	`{`
`349`	`349`	`std::string sval = wxTextCtrl::GetValue().ToStdString();`
`350`	`350`	`return ParseValue<T>(sval, min, max, rel_base, base);`
`351`	`351`	`}`
`352`	`352`
`353`	`353`	`template<typename T>`
`354`	`354`	`typename std::enable_if<std::is_same<T, BitOffset>::value, T>::type`
`355`		`- GetValue(T min = BitOffset::MIN, T max = BitOffset::MAX, T rel_base = BitOffset::ZERO, int base = 0, bool *bit_explicit = NULL)`
	`355`	`+ GetNumValue(T min = BitOffset::MIN, T max = BitOffset::MAX, T rel_base = BitOffset::ZERO, int base = 0, bool *bit_explicit = NULL)`
`356`	`356`	`{`
`357`	`357`	`std::string sval = wxTextCtrl::GetValue().ToStdString();`
`358`	`358`	`return ParseValue<T>(sval, min, max, rel_base, base, bit_explicit);`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/* Reverse Engineer's Hex Editor`
`2`		`- * Copyright (C) 2019-2024 Daniel Collins <solemnwarning@solemnwarning.net>`
	`2`	`+ * Copyright (C) 2019-2025 Daniel Collins <solemnwarning@solemnwarning.net>`
`3`	`3`	`*`
`4`	`4`	`* This program is free software; you can redistribute it and/or modify it`
`5`	`5`	`* under the terms of the GNU General Public License version 2 as published by`
`@@ -219,7 +219,7 @@ void REHex::RangeDialog::OnOK(wxCommandEvent &event)`
`219`	`219`	`BitOffset virt_offset;`
`220`	`220`	`bool virt_offset_bit;`
`221`	`221`	`try {`
`222`		`- virt_offset = range_from->GetValue<BitOffset>(BitOffset::MIN, BitOffset::MAX, BitOffset::ZERO, 0, &virt_offset_bit);`
	`222`	`+ virt_offset = range_from->GetNumValue<BitOffset>(BitOffset::MIN, BitOffset::MAX, BitOffset::ZERO, 0, &virt_offset_bit);`
`223`	`223`	`}`
`224`	`224`	`catch(const NumericTextCtrl::InputError &e)`
`225`	`225`	`{`
`@@ -243,7 +243,7 @@ void REHex::RangeDialog::OnOK(wxCommandEvent &event)`
`243`	`243`	`BitOffset virt_end_incl;`
`244`	`244`	`bool virt_end_bit;`
`245`	`245`	`try {`
`246`		`- virt_end_incl = range_to->GetValue<BitOffset>(BitOffset::MIN, BitOffset::MAX, BitOffset::ZERO, 0, &virt_end_bit);`
	`246`	`+ virt_end_incl = range_to->GetNumValue<BitOffset>(BitOffset::MIN, BitOffset::MAX, BitOffset::ZERO, 0, &virt_end_bit);`
`247`	`247`	`}`
`248`	`248`	`catch(const NumericTextCtrl::InputError &e)`
`249`	`249`	`{`
`@@ -266,7 +266,7 @@ void REHex::RangeDialog::OnOK(wxCommandEvent &event)`
`266`	`266`	`{`
`267`	`267`	`BitOffset length;`
`268`	`268`	`try {`
`269`		`- length = range_len->GetValue<BitOffset>(BitOffset(0, 1));`
	`269`	`+ length = range_len->GetNumValue<BitOffset>(BitOffset(0, 1));`
`270`	`270`	`}`
`271`	`271`	`catch(const NumericTextCtrl::InputError &e)`
`272`	`272`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/* Reverse Engineer's Hex Editor`
`2`		`- * Copyright (C) 2021 Daniel Collins <solemnwarning@solemnwarning.net>`
	`2`	`+ * Copyright (C) 2021-2025 Daniel Collins <solemnwarning@solemnwarning.net>`
`3`	`3`	`*`
`4`	`4`	`* This program is free software; you can redistribute it and/or modify it`
`5`	`5`	`* under the terms of the GNU General Public License version 2 as published by`
`@@ -184,20 +184,20 @@ off_t REHex::VirtualMappingDialog::get_real_base()`
`184`	`184`	`off_t min = 0;`
`185`	`185`	`off_t max = std::max<off_t>(0, (document->buffer_length() - 1));;`
`186`	`186`
`187`		`- return real_base_input->GetValue<off_t>(min, max);`
	`187`	`+ return real_base_input->GetNumValue<off_t>(min, max);`
`188`	`188`	`}`
`189`	`189`
`190`	`190`	`off_t REHex::VirtualMappingDialog::get_virt_base()`
`191`	`191`	`{`
`192`		`- return virt_base_input->GetValue<off_t>(0);`
	`192`	`+ return virt_base_input->GetNumValue<off_t>(0);`
`193`	`193`	`}`
`194`	`194`
`195`	`195`	`off_t REHex::VirtualMappingDialog::get_segment_length(off_t real_base)`
`196`	`196`	`{`
`197`	`197`	`off_t min = 1;`
`198`	`198`	`off_t max = document->buffer_length() - real_base;`
`199`	`199`
`200`		`- return segment_length_input->GetValue<off_t>(min, max);`
	`200`	`+ return segment_length_input->GetNumValue<off_t>(min, max);`
`201`	`201`	`}`
`202`	`202`
`203`	`203`	`void REHex::VirtualMappingDialog::update_warning()`
Original file line number	Diff line number	Diff line change
`@@ -1151,7 +1151,11 @@ int REHex::Document::allocate_highlight_colour(const wxString &label, const wxCo`
`1151`	`1151`	`}`
`1152`	`1152`
`1153`	`1153`	`_tracked_change("change highlight colours",`
`1154`		`- [this, primary_colour, secondary_colour, label, next_highlight_idx]()`
	`1154`	`+ [this, primary_colour, secondary_colour, label`
	`1155`	`+ #ifndef NDEBUG`
	`1156`	`+ , next_highlight_idx`
	`1157`	`+ #endif`
	`1158`	`+ ]()`
`1155`	`1159`	`{`
`1156`	`1160`	`auto new_colour_it = highlight_colour_map.add();`
`1157`	`1161`	`assert(new_colour_it != highlight_colour_map.end());`