Merge remote-tracking branch 'origin/encoding-as-datatype'

Makefile

@@ -46,6 +46,14 @@ LUA_LIBS   ?= $(call shell-or-die,pkg-config $(LUA_PKG) --libs)
 CFLAGS   := -Wall -std=c99   -ggdb -I. -Iinclude/ -IwxLua/modules/ $(CAPSTONE_CFLAGS) $(JANSSON_CFLAGS) $(LUA_CFLAGS) $(CFLAGS)
 CXXFLAGS := -Wall -std=c++11 -ggdb -I. -Iinclude/ -IwxLua/modules/ $(CAPSTONE_CFLAGS) $(JANSSON_CFLAGS) $(LUA_CFLAGS) $(WX_CXXFLAGS) $(CXXFLAGS)
 
+uname_S := $(shell uname -s 2>/dev/null)
+ifeq ($(uname_S),FreeBSD)
+	LDLIBS += -liconv
+endif
+ifeq ($(uname_S),OpenBSD)
+	LDLIBS += -liconv
+endif
+
 LDLIBS := $(WX_LIBS) $(CAPSTONE_LIBS) $(JANSSON_LIBS) $(LUA_LIBS) $(LDLIBS)
 
 ifeq ($(DEBUG),)
@@ -198,6 +206,7 @@ APP_OBJS := \
 	src/buffer.o \
 	src/BytesPerLineDialog.o \
 	src/ByteRangeSet.o \
+	src/CharacterEncoder.o \
 	src/ClickText.o \
 	src/CodeCtrl.o \
 	src/CommentTree.o \
@@ -260,6 +269,7 @@ TEST_OBJS := \
 	src/buffer.o \
 	src/ByteRangeSet.o \
 	src/BytesPerLineDialog.o \
+	src/CharacterEncoder.o \
 	src/ClickText.o \
 	src/CommentTree.o \
 	src/ConsoleBuffer.o \
@@ -289,6 +299,7 @@ TEST_OBJS := \
 	tests/buffer.o \
 	tests/ByteRangeMap.o \
 	tests/ByteRangeSet.o \
+	tests/CharacterEncoder.o \
 	tests/CommentsDataObject.o \
 	tests/CommentTree.o \
 	tests/ConsoleBuffer.o \

Makefile.win

@@ -20,7 +20,7 @@ EXTRA_APP_OBJS := res/winres.o
 
 WX_CONFIG ?= wx-config --static
 LDFLAGS   ?= -Wl,-Bstatic
-LDLIBS    += -lstdc++ -lwinpthread -Wl,-Bdynamic -static-libgcc -static-libstdc++ -lole32
+LDLIBS    += -lstdc++ -lwinpthread -liconv -Wl,-Bdynamic -static-libgcc -static-libstdc++ -lole32
 
 # Needed for PRIxNN macros from inttypes.h under MinGW
 CFLAGS   += -D__STDC_FORMAT_MACROS

src/App.hpp

@@ -189,6 +189,9 @@ namespace REHex {
 
 			static std::multimap<SetupPhase, const SetupHookFunction*> *setup_hooks;
 			void call_setup_hooks(SetupPhase phase);
+
+		public:
+			void _test_setup_hooks(SetupPhase phase);
 	};
 }
 

src/BasicDataTypes.cpp

@@ -76,30 +76,30 @@ IMPLEMENT_NDTR_CLASS(U16BEDataRegion, uint16_t, "u16be", "%" PRIu16, be16toh, ht
 IMPLEMENT_NDTR_CLASS(S16LEDataRegion, int16_t,  "s16le", "%" PRId16, le16toh, htole16, s16le_factory)
 IMPLEMENT_NDTR_CLASS(S16BEDataRegion, int16_t,  "s16be", "%" PRId16, be16toh, htobe16, s16be_factory)
 
-static REHex::DataTypeRegistration u16le_dtr("u16le", "unsigned 16-bit (little endian)", &u16le_factory, "Number", sizeof(uint16_t));
-static REHex::DataTypeRegistration u16be_dtr("u16be", "unsigned 16-bit (big endian)",    &u16be_factory, "Number", sizeof(uint16_t));
-static REHex::DataTypeRegistration s16le_dtr("s16le", "signed 16-bit (little endian)",   &s16le_factory, "Number", sizeof(int16_t));
-static REHex::DataTypeRegistration s16be_dtr("s16be", "signed 16-bit (big endian)",      &s16be_factory, "Number", sizeof(int16_t));
+static REHex::DataTypeRegistration u16le_dtr("u16le", "unsigned 16-bit (little endian)", &u16le_factory, std::vector<std::string>({"Number"}), sizeof(uint16_t));
+static REHex::DataTypeRegistration u16be_dtr("u16be", "unsigned 16-bit (big endian)",    &u16be_factory, std::vector<std::string>({"Number"}), sizeof(uint16_t));
+static REHex::DataTypeRegistration s16le_dtr("s16le", "signed 16-bit (little endian)",   &s16le_factory, std::vector<std::string>({"Number"}), sizeof(int16_t));
+static REHex::DataTypeRegistration s16be_dtr("s16be", "signed 16-bit (big endian)",      &s16be_factory, std::vector<std::string>({"Number"}), sizeof(int16_t));
 
 IMPLEMENT_NDTR_CLASS(U32LEDataRegion, uint32_t, "u32le", "%" PRIu32, le32toh, htole32, u32le_factory)
 IMPLEMENT_NDTR_CLASS(U32BEDataRegion, uint32_t, "u32be", "%" PRIu32, be32toh, htobe32, u32be_factory)
 IMPLEMENT_NDTR_CLASS(S32LEDataRegion, int32_t,  "s32le", "%" PRId32, le32toh, htole32, s32le_factory)
 IMPLEMENT_NDTR_CLASS(S32BEDataRegion, int32_t,  "s32be", "%" PRId32, be32toh, htobe32, s32be_factory)
 
-static REHex::DataTypeRegistration u32le_dtr("u32le", "unsigned 32-bit (little endian)", &u32le_factory, "Number", sizeof(uint32_t));
-static REHex::DataTypeRegistration u32be_dtr("u32be", "unsigned 32-bit (big endian)",    &u32be_factory, "Number", sizeof(uint32_t));
-static REHex::DataTypeRegistration s32le_dtr("s32le", "signed 32-bit (little endian)",   &s32le_factory, "Number", sizeof(int32_t));
-static REHex::DataTypeRegistration s32be_dtr("s32be", "signed 32-bit (big endian)",      &s32be_factory, "Number", sizeof(int32_t));
+static REHex::DataTypeRegistration u32le_dtr("u32le", "unsigned 32-bit (little endian)", &u32le_factory, std::vector<std::string>({"Number"}), sizeof(uint32_t));
+static REHex::DataTypeRegistration u32be_dtr("u32be", "unsigned 32-bit (big endian)",    &u32be_factory, std::vector<std::string>({"Number"}), sizeof(uint32_t));
+static REHex::DataTypeRegistration s32le_dtr("s32le", "signed 32-bit (little endian)",   &s32le_factory, std::vector<std::string>({"Number"}), sizeof(int32_t));
+static REHex::DataTypeRegistration s32be_dtr("s32be", "signed 32-bit (big endian)",      &s32be_factory, std::vector<std::string>({"Number"}), sizeof(int32_t));
 
 IMPLEMENT_NDTR_CLASS(U64LEDataRegion, uint64_t, "u64le", "%" PRIu64, le64toh, htole64, u64le_factory)
 IMPLEMENT_NDTR_CLASS(U64BEDataRegion, uint64_t, "u64be", "%" PRIu64, be64toh, htobe64, u64be_factory)
 IMPLEMENT_NDTR_CLASS(S64LEDataRegion, int64_t,  "s64le", "%" PRId64, le64toh, htole64, s64le_factory)
 IMPLEMENT_NDTR_CLASS(S64BEDataRegion, int64_t,  "s64be", "%" PRId64, be64toh, htobe64, s64be_factory)
 
-static REHex::DataTypeRegistration u64le_dtr("u64le", "unsigned 64-bit (little endian)", &u64le_factory, "Number", sizeof(uint64_t));
-static REHex::DataTypeRegistration u64be_dtr("u64be", "unsigned 64-bit (big endian)",    &u64be_factory, "Number", sizeof(uint64_t));
-static REHex::DataTypeRegistration s64le_dtr("s64le", "signed 64-bit (little endian)",   &s64le_factory, "Number", sizeof(int64_t));
-static REHex::DataTypeRegistration s64be_dtr("s64be", "signed 64-bit (big endian)",      &s64be_factory, "Number", sizeof(int64_t));
+static REHex::DataTypeRegistration u64le_dtr("u64le", "unsigned 64-bit (little endian)", &u64le_factory, std::vector<std::string>({"Number"}), sizeof(uint64_t));
+static REHex::DataTypeRegistration u64be_dtr("u64be", "unsigned 64-bit (big endian)",    &u64be_factory, std::vector<std::string>({"Number"}), sizeof(uint64_t));
+static REHex::DataTypeRegistration s64le_dtr("s64le", "signed 64-bit (little endian)",   &s64le_factory, std::vector<std::string>({"Number"}), sizeof(int64_t));
+static REHex::DataTypeRegistration s64be_dtr("s64be", "signed 64-bit (big endian)",      &s64be_factory, std::vector<std::string>({"Number"}), sizeof(int64_t));
 
 /* Endian conversion for floats.
  * These won't work on crazy platforms where integers and floats have different
@@ -183,8 +183,8 @@ static double htoled(double he_double) { return ledtoh(he_double); }
 IMPLEMENT_NDTR_CLASS_FLOAT(F32LEDataRegion, float,  "f32le", "%.9g", leftoh, htolef, f32le_factory)
 IMPLEMENT_NDTR_CLASS_FLOAT(F32BEDataRegion, float,  "f32be", "%.9g", beftoh, htobef, f32be_factory)
 
-static REHex::DataTypeRegistration f32le_dtr("f32le", "32-bit float (little endian)", &f32le_factory, "Number", sizeof(float));
-static REHex::DataTypeRegistration f32be_dtr("f32be", "32-bit float (big endian)",    &f32be_factory, "Number", sizeof(float));
+static REHex::DataTypeRegistration f32le_dtr("f32le", "32-bit float (little endian)", &f32le_factory, std::vector<std::string>({"Number"}), sizeof(float));
+static REHex::DataTypeRegistration f32be_dtr("f32be", "32-bit float (big endian)",    &f32be_factory, std::vector<std::string>({"Number"}), sizeof(float));
 
 #define IMPLEMENT_NDTR_CLASS_DOUBLE(NAME, T, LABEL, FMT, XTOH, HTOX, FACTORY_FUNC) \
 	REHex::NAME::NAME(SharedDocumentPointer &doc, off_t offset, off_t length, off_t virt_offset): \
@@ -231,5 +231,5 @@ static REHex::DataTypeRegistration f32be_dtr("f32be", "32-bit float (big endian)
 IMPLEMENT_NDTR_CLASS_DOUBLE(F64LEDataRegion, double, "f64le", "%.9g", ledtoh, htoled, f64le_factory)
 IMPLEMENT_NDTR_CLASS_DOUBLE(F64BEDataRegion, double, "f64be", "%.9g", bedtoh, htobed, f64be_factory)
 
-static REHex::DataTypeRegistration f64le_dtr("f64le", "64-bit float (double) (little endian)", &f64le_factory, "Number", sizeof(double));
-static REHex::DataTypeRegistration f64be_dtr("f64be", "64-bit float (double) (big endian)",    &f64be_factory, "Number", sizeof(double));
+static REHex::DataTypeRegistration f64le_dtr("f64le", "64-bit float (double) (little endian)", &f64le_factory, std::vector<std::string>({"Number"}), sizeof(double));
+static REHex::DataTypeRegistration f64be_dtr("f64be", "64-bit float (double) (big endian)",    &f64be_factory, std::vector<std::string>({"Number"}), sizeof(double));

src/ByteRangeMap.hpp

@@ -78,16 +78,23 @@ namespace REHex
 
 			std::vector< std::pair<Range, T> > ranges;
 
+			/* Last iterator returned by get_range(), used to avoid a lookup from
+			 * scratch when a nearby offset is requested again.
+			*/
+			mutable typename std::vector< std::pair<Range, T> >::const_iterator last_get_iter;
+
 		public:
 			/**
 			 * @brief Construct an empty map.
 			*/
 			ByteRangeMap(const T &default_value = T()):
-				default_value(default_value) {}
+				default_value(default_value),
+				last_get_iter(ranges.end()) {}
 
 			ByteRangeMap(const ByteRangeMap &src):
 				default_value(src.default_value),
-				ranges(src.ranges) {}
+				ranges(src.ranges),
+				last_get_iter(ranges.end()) {}
 
 			bool operator==(const ByteRangeMap<T> &rhs) const
 			{
@@ -107,7 +114,8 @@ namespace REHex
 			*/
 			template<typename I> ByteRangeMap(const I begin, const I end, const T &default_value = T()):
 				default_value(default_value),
-				ranges(begin, end) {}
+				ranges(begin, end),
+				last_get_iter(ranges.end()) {}
 
 			/**
 			 * @brief Search the map for a range encompassing the given offset.
@@ -182,6 +190,7 @@ namespace REHex
 			const_iterator begin() const { return ranges.begin(); }
 			const_iterator end() const { return ranges.end(); }
 			bool empty() const { return ranges.empty(); }
+			size_t size() const { return ranges.size(); }
 			const std::pair<Range, T> &front() const { assert(!ranges.empty()); return ranges.front(); }
 			const std::pair<Range, T> &back() const { assert(!ranges.empty()); return ranges.back(); }
 
@@ -211,6 +220,11 @@ namespace REHex
 
 template<typename T> typename REHex::ByteRangeMap<T>::const_iterator REHex::ByteRangeMap<T>::get_range(off_t offset) const
 {
+	if(last_get_iter != ranges.end() && last_get_iter->first.offset <= offset && (last_get_iter->first.offset + last_get_iter->first.length) > offset)
+	{
+		return last_get_iter;
+	}
+
 	/* Starting from the first element after us (or the end of the vector)... */
 	auto i = std::lower_bound(ranges.begin(), ranges.end(), std::make_pair(Range((offset + 1), 0), default_value));
 
@@ -223,6 +237,7 @@ template<typename T> typename REHex::ByteRangeMap<T>::const_iterator REHex::Byte
 		if(i->first.offset <= offset && (i->first.offset + i->first.length) > offset)
 		{
 			/* ...it does, return it. */
+			last_get_iter = i;
 			return i;
 		}
 	}
@@ -373,6 +388,8 @@ template<typename T> void REHex::ByteRangeMap<T>::set_range(off_t offset, off_t
 		erase_end = ranges.insert(erase_end, insert_after.front());
 		++erase_end;
 	}
+
+	last_get_iter = ranges.end();
 }
 
 template<typename T> void REHex::ByteRangeMap<T>::clear_range(off_t offset, off_t length)
@@ -449,6 +466,8 @@ template<typename T> void REHex::ByteRangeMap<T>::clear_range(off_t offset, off_
 		erase_end = ranges.insert(erase_end, insert_after.front());
 		++erase_end;
 	}
+
+	last_get_iter = ranges.end();
 }
 
 template<typename T> REHex::ByteRangeMap<T> REHex::ByteRangeMap<T>::get_slice(off_t offset, off_t length) const
@@ -574,6 +593,8 @@ template<typename T> bool REHex::ByteRangeMap<T>::data_inserted(off_t offset, of
 		ranges.insert(std::next(ranges.begin(), insert_idx), insert_elem[0]);
 	}
 
+	last_get_iter = ranges.end();
+
 	return elements_changed;
 }
 
@@ -659,6 +680,8 @@ template<typename T> bool REHex::ByteRangeMap<T>::data_erased(off_t offset, off_
 		elements_changed = true;
 	}
 
+	last_get_iter = ranges.end();
+
 	return elements_changed;
 }