Use standard exception classes

Use the more specific already included exception classes for common
errors to keep things more understandable.

8 files changed, 31 insertions, 33 deletions

diff --git a/common/rdr/BufferedInStream.cxx b/common/rdr/BufferedInStream.cxx
index 204202ec..bf94a950 100644
--- a/common/rdr/BufferedInStream.cxx
+++ b/common/rdr/BufferedInStream.cxx
@@ -24,7 +24,6 @@
 #include <assert.h>
 
 #include <rdr/BufferedInStream.h>
-#include <rdr/Exception.h>
 
 #include <rfb/util.h>
 
@@ -65,10 +64,12 @@ void BufferedInStream::ensureSpace(size_t needed)
     uint8_t* newBuffer;
 
     if (needed > MAX_BUF_SIZE)
-      throw Exception(rfb::format("BufferedInStream overrun: requested "
-                                  "size of %lu bytes exceeds maximum "
-                                  "of %lu bytes", (long unsigned)needed,
-                                  (long unsigned)MAX_BUF_SIZE));
+      throw std::out_of_range(rfb::format("BufferedInStream overrun: "
+                                          "requested size of %lu bytes "
+                                          "exceeds maximum of %lu "
+                                          "bytes",
+                                          (long unsigned)needed,
+                                          (long unsigned)MAX_BUF_SIZE));
 
     newSize = DEFAULT_BUF_SIZE;
     while (newSize < needed)
diff --git a/common/rdr/BufferedOutStream.cxx b/common/rdr/BufferedOutStream.cxx
index f5062bf2..efb71dd7 100644
--- a/common/rdr/BufferedOutStream.cxx
+++ b/common/rdr/BufferedOutStream.cxx
@@ -23,7 +23,6 @@
 #endif
 
 #include <rdr/BufferedOutStream.h>
-#include <rdr/Exception.h>
 
 #include <rfb/util.h>
 
@@ -139,10 +138,11 @@ void BufferedOutStream::overrun(size_t needed)
   // We'll need to allocate more buffer space...
 
   if (totalNeeded > MAX_BUF_SIZE)
-    throw Exception(rfb::format("BufferedOutStream overrun: requested "
-                                "size of %lu bytes exceeds maximum of "
-                                "%lu bytes", (long unsigned)totalNeeded,
-                                (long unsigned)MAX_BUF_SIZE));
+    throw std::out_of_range(rfb::format("BufferedOutStream overrun: "
+                                        "requested size of %lu bytes "
+                                        "exceeds maximum of %lu bytes",
+                                        (long unsigned)totalNeeded,
+                                        (long unsigned)MAX_BUF_SIZE));
 
   newSize = DEFAULT_BUF_SIZE;
   while (newSize < totalNeeded)
diff --git a/common/rdr/HexInStream.cxx b/common/rdr/HexInStream.cxx
index 11f98498..69c3e260 100644
--- a/common/rdr/HexInStream.cxx
+++ b/common/rdr/HexInStream.cxx
@@ -23,7 +23,6 @@
 
 #include <algorithm>
 #include <rdr/HexInStream.h>
-#include <rdr/Exception.h>
 #include <rfb/util.h>
 
 using namespace rdr;
@@ -46,7 +45,7 @@ bool HexInStream::fillBuffer() {
   uint8_t* optr = (uint8_t*) end;
   for (size_t i=0; i<length; i++) {
     if (!rfb::hexToBin((const char*)&iptr[i*2], 2, &optr[i], 1))
-      throw Exception("HexInStream: Invalid input data");
+      throw std::runtime_error("HexInStream: Invalid input data");
   }
 
   in_stream.setptr(length*2);
diff --git a/common/rdr/InStream.h b/common/rdr/InStream.h
index 939439e1..5623142c 100644
--- a/common/rdr/InStream.h
+++ b/common/rdr/InStream.h
@@ -28,7 +28,7 @@
 #include <stdint.h>
 #include <string.h> // for memcpy
 
-#include <rdr/Exception.h>
+#include <stdexcept>
 
 // Check that callers are using InStream properly,
 // useful when writing new protocol handling
@@ -101,21 +101,21 @@ namespace rdr {
     inline void setRestorePoint() {
 #ifdef RFB_INSTREAM_CHECK
       if (restorePoint != nullptr)
-        throw Exception("Nested use of input stream restore point");
+        throw std::logic_error("Nested use of input stream restore point");
 #endif
       restorePoint = ptr;
     }
     inline void clearRestorePoint() {
 #ifdef RFB_INSTREAM_CHECK
       if (restorePoint == nullptr)
-        throw Exception("Incorrect clearing of input stream restore point");
+        throw std::logic_error("Incorrect clearing of input stream restore point");
 #endif
       restorePoint = nullptr;
     }
     inline void gotoRestorePoint() {
 #ifdef RFB_INSTREAM_CHECK
       if (restorePoint == nullptr)
-        throw Exception("Incorrect activation of input stream restore point");
+        throw std::logic_error("Incorrect activation of input stream restore point");
 #endif
       ptr = restorePoint;
       clearRestorePoint();
@@ -176,7 +176,7 @@ namespace rdr {
     inline const uint8_t* getptr(size_t length) { check(length);
                                                   return ptr; }
     inline void setptr(size_t length) { if (length > avail())
-                                          throw Exception("Input stream overflow");
+                                          throw std::out_of_range("Input stream overflow");
                                         skip(length); }
 
   private:
@@ -189,11 +189,11 @@ namespace rdr {
     inline void check(size_t bytes) {
 #ifdef RFB_INSTREAM_CHECK
       if (bytes > checkedBytes)
-        throw Exception("Input stream used without underrun check");
+        throw std::logic_error("Input stream used without underrun check");
       checkedBytes -= bytes;
 #endif
       if (bytes > (size_t)(end - ptr))
-        throw Exception("InStream buffer underrun");
+        throw std::out_of_range("InStream buffer underrun");
     }
 
     // overrun() is implemented by a derived class to cope with buffer overrun.
diff --git a/common/rdr/MemOutStream.h b/common/rdr/MemOutStream.h
index 9bf2b810..bf05d92c 100644
--- a/common/rdr/MemOutStream.h
+++ b/common/rdr/MemOutStream.h
@@ -23,7 +23,6 @@
 #ifndef __RDR_MEMOUTSTREAM_H__
 #define __RDR_MEMOUTSTREAM_H__
 
-#include <rdr/Exception.h>
 #include <rdr/OutStream.h>
 
 namespace rdr {
@@ -61,7 +60,7 @@ namespace rdr {
         len = (end - start) * 2;
 
       if (len < (size_t)(end - start))
-        throw Exception("Overflow in MemOutStream::overrun()");
+        throw std::out_of_range("Overflow in MemOutStream::overrun()");
 
       uint8_t* newStart = new uint8_t[len];
       memcpy(newStart, start, ptr - start);
diff --git a/common/rdr/OutStream.h b/common/rdr/OutStream.h
index 2921b232..b78ec4b0 100644
--- a/common/rdr/OutStream.h
+++ b/common/rdr/OutStream.h
@@ -27,7 +27,8 @@
 #include <stdint.h>
 #include <string.h> // for memcpy
 
-#include <rdr/Exception.h>
+#include <stdexcept>
+
 #include <rdr/InStream.h>
 
 namespace rdr {
@@ -129,7 +130,7 @@ namespace rdr {
 
     inline uint8_t* getptr(size_t length) { check(length); return ptr; }
     inline void setptr(size_t length) { if (length > avail())
-                                          throw Exception("Output stream overflow");
+                                          throw std::out_of_range("Output stream overflow");
                                         ptr += length; }
 
   private:
diff --git a/common/rdr/ZlibInStream.cxx b/common/rdr/ZlibInStream.cxx
index a90d50f7..c9f8aeca 100644
--- a/common/rdr/ZlibInStream.cxx
+++ b/common/rdr/ZlibInStream.cxx
@@ -23,7 +23,6 @@
 #include <assert.h>
 
 #include <rdr/ZlibInStream.h>
-#include <rdr/Exception.h>
 #include <zlib.h>
 
 using namespace rdr;
@@ -50,7 +49,7 @@ void ZlibInStream::flushUnderlying()
 {
   while (bytesIn > 0) {
     if (!hasData(1))
-      throw Exception("ZlibInStream: failed to flush remaining stream data");
+      throw std::runtime_error("ZlibInStream: failed to flush remaining stream data");
     skip(avail());
   }
 
@@ -76,7 +75,7 @@ void ZlibInStream::init()
   if (inflateInit(zs) != Z_OK) {
     delete zs;
     zs = nullptr;
-    throw Exception("ZlibInStream: inflateInit failed");
+    throw std::runtime_error("ZlibInStream: inflateInit failed");
   }
 }
 
@@ -92,7 +91,7 @@ void ZlibInStream::deinit()
 bool ZlibInStream::fillBuffer()
 {
   if (!underlying)
-    throw Exception("ZlibInStream overrun: no underlying stream");
+    throw std::runtime_error("ZlibInStream overrun: no underlying stream");
 
   zs->next_out = (uint8_t*)end;
   zs->avail_out = availSpace();
@@ -107,7 +106,7 @@ bool ZlibInStream::fillBuffer()
 
   int rc = inflate(zs, Z_SYNC_FLUSH);
   if (rc < 0) {
-    throw Exception("ZlibInStream: inflate failed");
+    throw std::runtime_error("ZlibInStream: inflate failed");
   }
 
   bytesIn -= length - zs->avail_in;
diff --git a/common/rdr/ZlibOutStream.cxx b/common/rdr/ZlibOutStream.cxx
index 1b59f54e..13788f8d 100644
--- a/common/rdr/ZlibOutStream.cxx
+++ b/common/rdr/ZlibOutStream.cxx
@@ -24,7 +24,6 @@
 #include <stdio.h>
 
 #include <rdr/ZlibOutStream.h>
-#include <rdr/Exception.h>
 #include <rfb/LogWriter.h>
 
 #include <zlib.h>
@@ -46,7 +45,7 @@ ZlibOutStream::ZlibOutStream(OutStream* os, int compressLevel)
   zs->avail_in  = 0;
   if (deflateInit(zs, compressLevel) != Z_OK) {
     delete zs;
-    throw Exception("ZlibOutStream: deflateInit failed");
+    throw std::runtime_error("ZlibOutStream: deflateInit failed");
   }
 }
 
@@ -113,7 +112,7 @@ void ZlibOutStream::deflate(int flush)
   int rc;
 
   if (!underlying)
-    throw Exception("ZlibOutStream: underlying OutStream has not been set");
+    throw std::runtime_error("ZlibOutStream: underlying OutStream has not been set");
 
   if ((flush == Z_NO_FLUSH) && (zs->avail_in == 0))
     return;
@@ -134,7 +133,7 @@ void ZlibOutStream::deflate(int flush)
       if ((rc == Z_BUF_ERROR) && (flush != Z_NO_FLUSH))
         break;
 
-      throw Exception("ZlibOutStream: deflate failed");
+      throw std::runtime_error("ZlibOutStream: deflate failed");
     }
 
 #ifdef ZLIBOUT_DEBUG
@@ -168,7 +167,7 @@ void ZlibOutStream::checkCompressionLevel()
       // explicit flush we did above. It should be safe to ignore though
       // as the first flush should have left things in a stable state...
       if (rc != Z_BUF_ERROR)
-        throw Exception("ZlibOutStream: deflateParams failed");
+        throw std::runtime_error("ZlibOutStream: deflateParams failed");
     }
 
     compressionLevel = newLevel;