uhd: Add new exceptions for RFNoC-specific errors

Add the following exception types:
- rfnoc_error
- op_failed
- op_seqerr
- op_timeout
- op_timeerr
- access_error
  - It is meant to be used when access violations have taken place,
    i.e., when a resource is being accessed without appropriate
    permissions.
- resolve_error
  - This is a derivative of rfnoc_error, and will be used when a
    property resolution fails unexpectedly.
- routing_error
  - For use when the framework has path setup issues or general
    routing-related errors

2 files changed, 115 insertions, 7 deletions

diff --git a/host/include/uhd/exception.hpp b/host/include/uhd/exception.hpp
index 7189015a0..adedebe96 100644
--- a/host/include/uhd/exception.hpp
+++ b/host/include/uhd/exception.hpp
@@ -163,6 +163,17 @@ struct UHD_API not_implemented_error : runtime_error
     virtual void dynamic_throw(void) const;
 };
 
+/*! Raised when a resource is being accessed without having the appropriate
+ * permissions.
+ */
+struct UHD_API access_error : runtime_error
+{
+    access_error(const std::string& what);
+    virtual unsigned code(void) const;
+    virtual access_error* dynamic_clone(void) const;
+    virtual void dynamic_throw(void) const;
+};
+
 /*! Base class for errors that occur outside of UHD.
  */
 struct UHD_API environment_error : exception
@@ -215,6 +226,77 @@ struct UHD_API syntax_error : exception
     virtual void dynamic_throw(void) const;
 };
 
+/*! Base class for RFNoC-related errors
+ */
+struct UHD_API rfnoc_error : exception
+{
+    rfnoc_error(const std::string& what);
+    virtual unsigned code(void) const;
+    virtual rfnoc_error* dynamic_clone(void) const;
+    virtual void dynamic_throw(void) const;
+};
+
+/*! Gets thrown when a transaction with an RFNoC block fails (IO error)
+ */
+struct UHD_API op_failed : rfnoc_error
+{
+    op_failed(const std::string& what);
+    virtual unsigned code(void) const;
+    virtual op_failed* dynamic_clone(void) const;
+    virtual void dynamic_throw(void) const;
+};
+
+/*! Gets thrown when a transaction with an RFNoC block times out (e.g., no ACK
+ *  received)
+ */
+struct UHD_API op_timeout : rfnoc_error
+{
+    op_timeout(const std::string& what);
+    virtual unsigned code(void) const;
+    virtual op_timeout* dynamic_clone(void) const;
+    virtual void dynamic_throw(void) const;
+};
+
+/*! Gets thrown when a transaction with an RFNoC yields a sequence error
+ */
+struct UHD_API op_seqerr : rfnoc_error
+{
+    op_seqerr(const std::string& what);
+    virtual unsigned code(void) const;
+    virtual op_seqerr* dynamic_clone(void) const;
+    virtual void dynamic_throw(void) const;
+};
+
+/*! Gets thrown when a transaction with an RFNoC yields a time error (late command)
+ */
+struct UHD_API op_timerr : rfnoc_error
+{
+    op_timerr(const std::string& what);
+    virtual unsigned code(void) const;
+    virtual op_timerr* dynamic_clone(void) const;
+    virtual void dynamic_throw(void) const;
+};
+
+/*! Gets thrown when a property resolution fails
+ */
+struct UHD_API resolve_error : rfnoc_error
+{
+    resolve_error(const std::string& what);
+    virtual unsigned code(void) const;
+    virtual resolve_error* dynamic_clone(void) const;
+    virtual void dynamic_throw(void) const;
+};
+
+/*! Gets thrown when there is a routing-related failure in RFNoC
+ */
+struct UHD_API routing_error : rfnoc_error
+{
+    routing_error(const std::string& what);
+    virtual unsigned code(void) const;
+    virtual routing_error* dynamic_clone(void) const;
+    virtual void dynamic_throw(void) const;
+};
+
 /*!
  * Create a formatted string with throw-site information.
  * Fills in the function name, file name, and line number.
diff --git a/host/lib/exception.cpp b/host/lib/exception.cpp
index a413e53c2..03c319fac 100644
--- a/host/lib/exception.cpp
+++ b/host/lib/exception.cpp
@@ -1,18 +1,23 @@
 //
 // Copyright 2011 Ettus Research LLC
 // Copyright 2018 Ettus Research, a National Instruments Company
+// Copyright 2019 Ettus Research, a National Instruments Brand
 //
 // SPDX-License-Identifier: GPL-3.0-or-later
 //
 
 #include <uhd/exception.hpp>
-#include <boost/functional/hash.hpp>
 #include <boost/format.hpp>
+#include <boost/functional/hash.hpp>
 
 using namespace uhd;
 
-exception::exception(const std::string &what):
-    std::runtime_error(what){/* NOP */}
+exception::exception(const std::string& what) : std::runtime_error(what)
+{ /* NOP */
+}
+
+// The formatting is fickle in this macro-magic
+// clang-format off
 
 #define make_exception_impl(name, class, base) \
     class::class(const std::string &what): \
@@ -30,13 +35,34 @@ make_exception_impl("ValueError",            value_error,             exception)
 make_exception_impl("NarrowingError",        narrowing_error,         value_error)
 make_exception_impl("RuntimeError",          runtime_error,           exception)
 make_exception_impl("NotImplementedError",   not_implemented_error,   runtime_error)
+make_exception_impl("AccessError",           access_error,            runtime_error)
 make_exception_impl("EnvironmentError",      environment_error,       exception)
 make_exception_impl("IOError",               io_error,                environment_error)
 make_exception_impl("OSError",               os_error,                environment_error)
 make_exception_impl("SystemError",           system_error,            exception)
 make_exception_impl("SyntaxError",           syntax_error,            exception)
+make_exception_impl("RfnocError",            rfnoc_error,             exception)
+make_exception_impl("OpFailed",              op_failed,               rfnoc_error)
+make_exception_impl("OpTimeout",             op_timeout,              rfnoc_error)
+make_exception_impl("OpSeqerr",              op_seqerr,               rfnoc_error)
+make_exception_impl("OpTimeErr",             op_timerr,               rfnoc_error)
+make_exception_impl("ResolveError",          resolve_error,           rfnoc_error)
+make_exception_impl("RoutingError",          routing_error,           rfnoc_error)
+
+
+usb_error::usb_error(int code, const std::string &what) :
+    runtime_error(str(boost::format("%s %d: %s") % "USBError" % code % what)),
+    _code(code)
+{}
+
+// clang-format on
+
+usb_error* usb_error::dynamic_clone(void) const
+{
+    return new usb_error(*this);
+}
 
-usb_error::usb_error(int code, const std::string &what):
-    runtime_error(str(boost::format("%s %d: %s") % "USBError" % code % what)), _code(code) {}
-usb_error *usb_error::dynamic_clone(void) const{return new usb_error(*this);} \
-void usb_error::dynamic_throw(void) const{throw *this;}
+void usb_error::dynamic_throw(void) const
+{
+    throw *this;
+}