Golfish exceptions to subclass std::exception

Author: VincentLascaux

inc/goldfish/base64_stream.h

@@ -5,7 +5,7 @@
 
 namespace goldfish { namespace stream
 {
-	struct ill_formatted_base64_data : ill_formatted {};
+	struct ill_formatted_base64_data : ill_formatted { using ill_formatted::ill_formatted; };
 
 	// Reads binary data assuming inner reads base64
 	template <class inner> class base64_reader
@@ -57,22 +57,22 @@ namespace goldfish { namespace stream
 				else
 					c_read = 3;
 
-				if (stream::seek(m_stream, 1) != 0) // Padding is only allowed at the end of the stream
-					throw ill_formatted_base64_data{};
+				if (stream::seek(m_stream, 1) != 0)
+					throw ill_formatted_base64_data{ "'=' is only allowed at the end of a base64 stream" };
 			}
 
 			if (c_read == 0)
 				return 0;
 			if (c_read == 1)
-				throw ill_formatted_base64_data{};
+				throw ill_formatted_base64_data{ "Unexpected number of characters in base64 stream" };
 
 			auto a = character_to_6bits(buffer[0]);
 			auto b = character_to_6bits(buffer[1]);
 			output[0] = ((a << 2) | (b >> 4));
 			if (c_read == 2)
 			{
 				if (b & 0xF)
-					throw ill_formatted_base64_data{};
+					throw ill_formatted_base64_data{ "Invalid character at end of base64 stream" };
 				return 1;
 			}
 
@@ -81,7 +81,7 @@ namespace goldfish { namespace stream
 			if (c_read == 3)
 			{
 				if (c & 0x3)
-					throw ill_formatted_base64_data{};
+					throw ill_formatted_base64_data{ "Invalid character at end of base64 stream" };
 				return 2;
 			}
 
@@ -122,7 +122,7 @@ namespace goldfish { namespace stream
 			static_assert(sizeof(lookup_table) == 256, "");
 			auto result = lookup_table[c];
 			if (result >= 64)
-				throw ill_formatted_base64_data{};
+				throw ill_formatted_base64_data{ "Invalid character in base64 stream" };
 			return result;
 		}
 		inner m_stream;

inc/goldfish/cbor_reader.h

@@ -11,7 +11,7 @@
 
 namespace goldfish { namespace cbor
 {
-	struct ill_formatted_cbor_data : ill_formatted {};
+	struct ill_formatted_cbor_data : ill_formatted { using ill_formatted::ill_formatted; };
 
 	template <class Stream, byte expected_type, class _tag> class string;
 	template <class Stream> using byte_string = string<Stream, 2, tags::binary>;
@@ -53,7 +53,7 @@ namespace goldfish { namespace cbor
 			, m_remaining_in_current_block(cb_initial)
 		{
 			if (m_remaining_in_current_block >= invalid_remaining)
-				throw ill_formatted_cbor_data{};
+				throw ill_formatted_cbor_data{ "CBOR string too large" };
 		}
 
 		size_t read_partial_buffer(buffer_ref buffer)
@@ -74,7 +74,7 @@ namespace goldfish { namespace cbor
 			{
 				auto to_skip = std::min(cb, m_remaining_in_current_block);
 				if (stream::seek(m_stream, to_skip) != to_skip)
-					throw ill_formatted_cbor_data{};
+					throw ill_formatted_cbor_data{ "Unexpected end of stream while reading CBOR string" };
 				cb -= to_skip;
 				m_remaining_in_current_block -= to_skip;
 			}
@@ -100,11 +100,11 @@ namespace goldfish { namespace cbor
 					}
 
 					if ((b >> 5) != expected_type)
-						throw ill_formatted_cbor_data{};
+						throw ill_formatted_cbor_data{ "Unexpected type in CBOR string block" };
 
 					auto cb_next_block = read_integer(b & 31, m_stream);
 					if (cb_next_block >= invalid_remaining)
-						throw ill_formatted_cbor_data{};
+						throw ill_formatted_cbor_data{ "CBOR string too large" };
 					m_remaining_in_current_block = cb_next_block;
 				}
 				return m_remaining_in_current_block != invalid_remaining;
@@ -128,7 +128,7 @@ namespace goldfish { namespace cbor
 			, m_remaining_length(length)
 		{
 			if (m_remaining_length == std::numeric_limits<uint64_t>::max())
-				throw ill_formatted_cbor_data{};
+				throw ill_formatted_cbor_data{ "CBOR array too large" };
 		}
 		array(Stream&& s)
 			: m_stream(std::move(s))
@@ -149,7 +149,7 @@ namespace goldfish { namespace cbor
 				if (m_remaining_length == std::numeric_limits<uint64_t>::max())
 					m_remaining_length = 0;
 				else
-					throw ill_formatted_cbor_data{};
+					throw ill_formatted_cbor_data{ "CBOR array too large" };
 			}
 			return document;
 		}
@@ -168,7 +168,7 @@ namespace goldfish { namespace cbor
 			, m_remaining_length(remaining_length)
 		{
 			if (m_remaining_length == std::numeric_limits<uint64_t>::max())
-				throw ill_formatted_cbor_data{};
+				throw ill_formatted_cbor_data{ "CBOR map too large" };
 		}
 		map(Stream&& s)
 			: m_stream(std::move(s))
@@ -187,7 +187,7 @@ namespace goldfish { namespace cbor
 				if (m_remaining_length == std::numeric_limits<uint64_t>::max())
 					m_remaining_length = 0;
 				else
-					throw ill_formatted_cbor_data{};
+					throw ill_formatted_cbor_data{ "Unexpected break code found in finite length map" };
 			}
 			if (m_remaining_length != std::numeric_limits<uint64_t>::max())
 				--m_remaining_length;
@@ -197,7 +197,7 @@ namespace goldfish { namespace cbor
 		{
 			auto d = read_no_debug_check(stream::ref(m_stream));
 			if (!d)
-				throw ill_formatted_cbor_data{};
+				throw ill_formatted_cbor_data{ "Unexpected break code found as a map value" };
 			return std::move(*d);
 		}
 	private:
@@ -226,7 +226,7 @@ namespace goldfish { namespace cbor
 		else if (additional == 27)
 			return from_big_endian(read<uint64_t>(s));
 		else
-			throw ill_formatted_cbor_data{};
+			throw ill_formatted_cbor_data{ "Bad CBOR integer encoding" };
 	}
 	template <class stream> double read_half_point_float(stream& s)
 	{
@@ -253,7 +253,7 @@ namespace goldfish { namespace cbor
 		{
 			auto x = read_integer(static_cast<byte>(first_byte & 31), s);
 			if (x > static_cast<uint64_t>(std::numeric_limits<int64_t>::max()))
-				throw ill_formatted_cbor_data{};
+				throw ill_formatted_cbor_data{ "CBOR signed integer too large" };
 
 			return -1 - static_cast<int64_t>(x);
 		}
@@ -278,7 +278,7 @@ namespace goldfish { namespace cbor
 		static optional<document<Stream>> fn_float_16(Stream&& s, byte) { return read_half_point_float(s); }
 		static optional<document<Stream>> fn_float_32(Stream&& s, byte) { return double{ to_float(from_big_endian(stream::read<uint32_t>(s))) }; }
 		static optional<document<Stream>> fn_float_64(Stream&& s, byte) { return to_double(from_big_endian(stream::read<uint64_t>(s))); }
-		static optional<document<Stream>> fn_ill_formatted(Stream&&, byte) { throw ill_formatted_cbor_data{}; };
+		static optional<document<Stream>> fn_ill_formatted(Stream&&, byte) { throw ill_formatted_cbor_data{ "Unexpected CBOR opcode" }; };
 
 		static optional<document<Stream>> fn_small_binary(Stream&& s, byte first_byte) { return byte_string<Stream>{ std::move(s), static_cast<uint8_t>(first_byte & 31) }; };
 		static optional<document<Stream>> fn_8_binary(Stream&& s, byte) { return byte_string<Stream>{ std::move(s), stream::read<uint8_t>(s) }; };
@@ -392,7 +392,7 @@ namespace goldfish { namespace cbor
 	{
 		auto d = read_no_debug_check(std::forward<Stream>(s));
 		if (!d)
-			throw ill_formatted_cbor_data{};
+			throw ill_formatted_cbor_data{ "Unexpected break code in CBOR stream" };
 		return debug_checks::add_read_checks(std::move(*d), e);
 	}
 	template <class Stream> auto read(Stream&& s) { return read(std::forward<Stream>(s), debug_checks::default_error_handler{}); }

inc/goldfish/common.h

@@ -17,17 +17,26 @@ namespace goldfish
 	inline uint64_t to_big_endian(uint64_t x) { return from_big_endian(x); }
 
 	// All goldfish exceptions subclass this exception
-	struct exception {};
+	class exception : public std::exception
+	{
+	public:
+		exception(const char* w)
+			: m_what(w)
+		{}
+		const char* what() const noexcept override { return m_what; }
+	private:
+		const char* m_what;
+	};
 
 	// Base class for all formatting errors that happen while parsing a document
-	struct ill_formatted : exception {};
+	struct ill_formatted : exception { using exception::exception; };
 
 	// Specifically for IO errors, thrown by file_reader/writer and istream_reader/writer
-	struct io_exception : exception {};
+	struct io_exception : exception { using exception::exception; };
 	struct io_exception_with_error_code : io_exception
 	{
-		io_exception_with_error_code(int _error_code)
-			: error_code(_error_code)
+		io_exception_with_error_code(const char* w, int _error_code)
+			: io_exception(w), error_code(_error_code)
 		{}
 
 		int error_code;

inc/goldfish/file_stream.h

@@ -14,12 +14,12 @@ namespace goldfish { namespace stream
 			file_handle(const char* path, const char* mode)
 			{
 				if (auto error = fopen_s(&m_fp, path, mode))
-					throw io_exception_with_error_code{ error };
+					throw io_exception_with_error_code{ "Error during file open", error };
 			}
 			file_handle(const wchar_t* path, const wchar_t* wmode)
 			{
 				if (auto error = _wfopen_s(&m_fp, path, wmode))
-					throw io_exception_with_error_code{ error };
+					throw io_exception_with_error_code{ "Error during file open", error };
 			}
 			file_handle(const std::string& path, const char* mode)
 				: file_handle(path.c_str(), mode)
@@ -68,7 +68,7 @@ namespace goldfish { namespace stream
 			if (cb != data.size())
 			{
 				if (auto error = ferror(m_file.get()))
-					throw io_exception_with_error_code{ error };
+					throw io_exception_with_error_code{ "Error during file read", error };
 			}
 			return cb;
 		}
@@ -95,7 +95,7 @@ namespace goldfish { namespace stream
 		void write_buffer(const_buffer_ref data)
 		{
 			if (fwrite(data.data(), 1 /*size*/, data.size() /*count*/, m_file.get()) != data.size())
-				throw io_exception_with_error_code{ ferror(m_file.get()) };
+				throw io_exception_with_error_code{ "Error during file write", ferror(m_file.get()) };
 		}
 		void flush() { }
 	private:

inc/goldfish/iostream_adaptor.h

@@ -18,11 +18,11 @@ namespace goldfish { namespace stream
 				return 0;
 
 			if (auto cb = m_stream.readsome(reinterpret_cast<char*>(buffer.data()), buffer.size()))
-				return cb;
+				return static_cast<size_t>(cb); // static_cast is OK because cb <= buffer.size(), which is a size_t
 
 			m_stream.read(reinterpret_cast<char*>(buffer.data()), 1);
 			if (m_stream.bad() || (m_stream.fail() && !m_stream.eof()))
-				throw io_exception{};
+				throw io_exception{ "istream read failed" };
 
 			return static_cast<size_t>(m_stream.gcount());
 		}
@@ -39,13 +39,13 @@ namespace goldfish { namespace stream
 		{
 			m_stream.write(reinterpret_cast<const char*>(buffer.data()), buffer.size());
 			if (m_stream.fail())
-				throw io_exception{};
+				throw io_exception{ "ostream write failed" };
 		}
 		void flush()
 		{
 			m_stream.flush();
 			if (m_stream.fail())
-				throw io_exception{};
+				throw io_exception{ "ostream flush failed" };
 		}
 	private:
 		std::ostream& m_stream;