Merge branch 'maint'

Conflicts:
	host/include/uhd/transport/vrt_if_packet.hpp

18 files changed, 71 insertions, 71 deletions

diff --git a/host/examples/txrx_loopback_to_file.cpp b/host/examples/txrx_loopback_to_file.cpp
index d98c5187d..7dc3bd9c2 100644
--- a/host/examples/txrx_loopback_to_file.cpp
+++ b/host/examples/txrx_loopback_to_file.cpp
@@ -137,7 +137,7 @@ template<typename samp_type> void recv_to_file(
     UHD_ASSERT_THROW(outfiles.size() == buffs.size());
     UHD_ASSERT_THROW(buffs.size() == rx_channel_nums.size());
     bool overflow_message = true;
-    float timeout = settling_time + 0.1; //expected settling time + padding for first recv
+    float timeout = settling_time + 0.1f; //expected settling time + padding for first recv
 
     //setup streaming
     uhd::stream_cmd_t stream_cmd((num_requested_samples == 0)?
@@ -151,7 +151,7 @@ template<typename samp_type> void recv_to_file(
 
     while(not stop_signal_called and (num_requested_samples != num_total_samps or num_requested_samples == 0)){
         size_t num_rx_samps = rx_stream->recv(buff_ptrs, samps_per_buff, md, timeout);
-        timeout = 0.1; //small timeout for subsequent recv
+        timeout = 0.1f; //small timeout for subsequent recv
 
         if (md.error_code == uhd::rx_metadata_t::ERROR_CODE_TIMEOUT) {
             std::cout << boost::format("Timeout while streaming") << std::endl;
diff --git a/host/include/uhd/transport/vrt_if_packet.hpp b/host/include/uhd/transport/vrt_if_packet.hpp
index 8bc65cdf1..1e54607c1 100644
--- a/host/include/uhd/transport/vrt_if_packet.hpp
+++ b/host/include/uhd/transport/vrt_if_packet.hpp
@@ -46,7 +46,7 @@ namespace vrt{
         {
             LINK_TYPE_NONE = 0x0,
             LINK_TYPE_CHDR = 0x1,
-            LINK_TYPE_VRLP = 0x2,
+            LINK_TYPE_VRLP = 0x2
         } link_type;
 
         //packet type
@@ -63,7 +63,7 @@ namespace vrt{
             PACKET_TYPE_ACK       = 0x1, // Flow control (ack)
             PACKET_TYPE_CMD       = 0x2, // Command
             PACKET_TYPE_RESP      = 0x3, // Command response
-            PACKET_TYPE_ERROR     = 0x3, // Command response: Error (the EOB bit is raised in this case)
+            PACKET_TYPE_ERROR     = 0x3  // Command response: Error (the EOB bit is raised in this case)
         } packet_type;
 
         //size fields
diff --git a/host/include/uhd/types/clock_config.hpp b/host/include/uhd/types/clock_config.hpp
index 27b312245..6d5d01ec2 100644
--- a/host/include/uhd/types/clock_config.hpp
+++ b/host/include/uhd/types/clock_config.hpp
@@ -47,12 +47,12 @@ namespace uhd{
             REF_AUTO = int('a'), //automatic (device specific)
             REF_INT  = int('i'), //internal reference
             REF_SMA  = int('s'), //external sma port
-            REF_MIMO = int('m'), //reference from mimo cable
+            REF_MIMO = int('m')  //reference from mimo cable
         } ref_source;
         enum pps_source_t {
             PPS_INT  = int('i'), //there is no internal
             PPS_SMA  = int('s'), //external sma port
-            PPS_MIMO = int('m'), //time sync from mimo cable
+            PPS_MIMO = int('m')  //time sync from mimo cable
         } pps_source;
         enum pps_polarity_t {
             PPS_NEG = int('n'), //negative edge
diff --git a/host/include/uhd/utils/fp_compare_delta.ipp b/host/include/uhd/utils/fp_compare_delta.ipp
index 092ade6e9..49cbc281b 100644
--- a/host/include/uhd/utils/fp_compare_delta.ipp
+++ b/host/include/uhd/utils/fp_compare_delta.ipp
@@ -100,8 +100,8 @@ namespace uhd { namespace math { namespace fp_compare {
 
     template<typename float_t> UHD_INLINE
     bool operator==(fp_compare_delta<float_t> lhs, double rhs) {
-        float_t delta = fp_compare_select_delta(double(lhs._delta),
-                DOUBLE_PRECISION_DELTA);
+        float_t delta = float_t(fp_compare_select_delta(double(lhs._delta),
+                DOUBLE_PRECISION_DELTA));
         return (std::fabs(lhs._value - rhs) < delta);
     }
 
@@ -112,8 +112,8 @@ namespace uhd { namespace math { namespace fp_compare {
 
     template<typename float_t> UHD_INLINE
     bool operator<(fp_compare_delta<float_t> lhs, double rhs) {
-        float_t delta = fp_compare_select_delta(double(lhs._delta),
-                DOUBLE_PRECISION_DELTA);
+        float_t delta = float_t(fp_compare_select_delta(double(lhs._delta),
+                DOUBLE_PRECISION_DELTA));
         return ((rhs - lhs._value) > delta);
     }
 
@@ -124,8 +124,8 @@ namespace uhd { namespace math { namespace fp_compare {
 
     template<typename float_t> UHD_INLINE
     bool operator>(fp_compare_delta<float_t> lhs, double rhs) {
-        float_t delta = fp_compare_select_delta(double(lhs._delta),
-                DOUBLE_PRECISION_DELTA);
+        float_t delta = float_t(fp_compare_select_delta(double(lhs._delta),
+                DOUBLE_PRECISION_DELTA));
         return ((lhs._value - rhs) > delta);
     }
 
@@ -148,8 +148,8 @@ namespace uhd { namespace math { namespace fp_compare {
 
     template<typename float_t> UHD_INLINE
     bool operator<(double lhs, fp_compare_delta<float_t> rhs) {
-        float_t delta = fp_compare_select_delta(DOUBLE_PRECISION_DELTA,
-                double(rhs._delta));
+        float_t delta = float_t(fp_compare_select_delta(DOUBLE_PRECISION_DELTA,
+                double(rhs._delta)));
         return ((rhs._value - lhs) > delta);
     }
 
@@ -160,8 +160,8 @@ namespace uhd { namespace math { namespace fp_compare {
 
     template<typename float_t> UHD_INLINE
     bool operator>(double lhs, fp_compare_delta<float_t> rhs) {
-        float_t delta = fp_compare_select_delta(DOUBLE_PRECISION_DELTA,
-                double(rhs._delta));
+        float_t delta = float_t(fp_compare_select_delta(DOUBLE_PRECISION_DELTA,
+                double(rhs._delta)));
         return ((lhs - rhs._value) > delta);
     }
 
diff --git a/host/include/uhd/utils/log.hpp b/host/include/uhd/utils/log.hpp
index 5baa00108..106c0d9d5 100644
--- a/host/include/uhd/utils/log.hpp
+++ b/host/include/uhd/utils/log.hpp
@@ -76,7 +76,7 @@ namespace uhd{ namespace _log{
         regularly   = 3,
         rarely      = 4,
         very_rarely = 5,
-        never       = 6,
+        never       = 6
     };
 
     //! Internal logging object (called by UHD_LOG macros)
@@ -101,12 +101,12 @@ namespace uhd{ namespace _log{
 
         // General insertion overload
         template <typename T>
-        INSERTION_OVERLOAD(T val);
+        INSERTION_OVERLOAD(T val)
 
         // Insertion overloads for std::ostream manipulators
-        INSERTION_OVERLOAD(std::ostream& (*val)(std::ostream&));
-        INSERTION_OVERLOAD(std::ios& (*val)(std::ios&));
-        INSERTION_OVERLOAD(std::ios_base& (*val)(std::ios_base&));
+        INSERTION_OVERLOAD(std::ostream& (*val)(std::ostream&))
+        INSERTION_OVERLOAD(std::ios& (*val)(std::ios&))
+        INSERTION_OVERLOAD(std::ios_base& (*val)(std::ios_base&))
 
     private:
         std::ostringstream _ss;
diff --git a/host/include/uhd/utils/math.hpp b/host/include/uhd/utils/math.hpp
index 275a94f72..46a1cf7e4 100644
--- a/host/include/uhd/utils/math.hpp
+++ b/host/include/uhd/utils/math.hpp
@@ -60,7 +60,7 @@ namespace math {
      * values, a custom epsilon should be defined for those computations. This
      * use-case is provided for in the `fp_compare_epsilon` class constructor.
      */
-    static const float SINGLE_PRECISION_EPSILON = 1.19e-7;
+    static const float SINGLE_PRECISION_EPSILON = 1.19e-7f;
     static const double DOUBLE_PRECISION_EPSILON = 2.22e-16;
 
 namespace fp_compare {
@@ -155,7 +155,7 @@ namespace fp_compare {
      * These are the default deltas used by the 'fp_compare_delta' class for
      * single and double-precision floating point comparisons.
      */
-    static const float SINGLE_PRECISION_DELTA = 1e-3;
+    static const float SINGLE_PRECISION_DELTA = 1e-3f;
     static const double DOUBLE_PRECISION_DELTA = 1e-5;
 
     /*! Floating-point delta to use for frequency comparisons. */
diff --git a/host/lib/usrp/b200/b200_impl.cpp b/host/lib/usrp/b200/b200_impl.cpp
index b1ab6ea7d..693109b1b 100644
--- a/host/lib/usrp/b200/b200_impl.cpp
+++ b/host/lib/usrp/b200/b200_impl.cpp
@@ -1122,6 +1122,6 @@ sensor_value_t b200_impl::get_ref_locked(void)
 sensor_value_t b200_impl::get_fe_pll_locked(const bool is_tx)
 {
     const boost::uint32_t st = _local_ctrl->peek32(RB32_CORE_PLL);
-    const bool locked = is_tx ? st & 0x1 : st & 0x2;
+    const bool locked = is_tx ? bool(st & 0x1) : bool(st & 0x2);
     return sensor_value_t("LO", locked, "locked", "unlocked");
 }
diff --git a/host/lib/usrp/cores/rx_dsp_core_3000.cpp b/host/lib/usrp/cores/rx_dsp_core_3000.cpp
index 13d69920a..8a131ffb4 100644
--- a/host/lib/usrp/cores/rx_dsp_core_3000.cpp
+++ b/host/lib/usrp/cores/rx_dsp_core_3000.cpp
@@ -72,7 +72,7 @@ public:
     {
         UHD_SAFE_CALL
         (
-            //NOP
+            ;//NOP
         )
     }
 
diff --git a/host/lib/usrp/cores/time_core_3000.cpp b/host/lib/usrp/cores/time_core_3000.cpp
index aa5d5593d..ffae5dc0d 100644
--- a/host/lib/usrp/cores/time_core_3000.cpp
+++ b/host/lib/usrp/cores/time_core_3000.cpp
@@ -50,7 +50,7 @@ struct time_core_3000_impl : time_core_3000
     {
         UHD_SAFE_CALL
         (
-            //NOP
+            ;//NOP
         )
     }
 
@@ -71,8 +71,8 @@ struct time_core_3000_impl : time_core_3000
         UHD_MSG(status) << ((test_fail)? " fail" : "pass") << std::endl;
 
         //useful warning for debugging actual rate
-        const size_t ticks_elapsed = _tick_rate*approx_secs;
-        const size_t appox_rate = ticks_elapsed/(sleep_millis/1e3);
+        const size_t ticks_elapsed = size_t(_tick_rate*approx_secs);
+        const size_t appox_rate = size_t(ticks_elapsed/(sleep_millis/1e3));
         if (test_fail) UHD_MSG(warning)
             << "Expecting clock rate: " << (_tick_rate/1e6) << " MHz\n"
             << "Appoximate clock rate: " << (appox_rate/1e6) << " MHz\n"
diff --git a/host/lib/usrp/dboard/db_cbx.cpp b/host/lib/usrp/dboard/db_cbx.cpp
index db7f84932..ad255460e 100644
--- a/host/lib/usrp/dboard/db_cbx.cpp
+++ b/host/lib/usrp/dboard/db_cbx.cpp
@@ -142,7 +142,7 @@ double sbx_xcvr::cbx::set_lo_freq(dboard_iface::unit_t unit, double target_freq)
         }
 
         //keep pfd freq low enough to achieve 50kHz BS clock
-        BS = std::ceil(pfd_freq / 50e3);
+        BS = int(std::ceil(pfd_freq / 50e3));
         if(BS <= 1023) break;
     }
 
diff --git a/host/lib/usrp/dboard/db_ubx.cpp b/host/lib/usrp/dboard/db_ubx.cpp
index b6cc1421c..5184d2ecb 100644
--- a/host/lib/usrp/dboard/db_ubx.cpp
+++ b/host/lib/usrp/dboard/db_ubx.cpp
@@ -84,7 +84,7 @@ protected:
         // Get only regs with changes
         try {
             changed_regs = get_changed_addrs();
-        } catch (uhd::runtime_error& e) {
+        } catch (uhd::runtime_error&) {
             // No saved state - write all regs
             for (int addr = 5; addr >= 0; addr--)
                 changed_regs.insert(boost::uint32_t(addr));
diff --git a/host/lib/usrp/multi_usrp.cpp b/host/lib/usrp/multi_usrp.cpp
index 570c67875..1866255c9 100644
--- a/host/lib/usrp/multi_usrp.cpp
+++ b/host/lib/usrp/multi_usrp.cpp
@@ -848,7 +848,7 @@ public:
          * If device is in AGC mode it will ignore the setting. */
         try {
             return rx_gain_group(chan)->set_value(gain, name);
-        } catch (uhd::key_error &e) {
+        } catch (uhd::key_error &) {
             THROW_GAIN_NAME_ERROR(name,chan,rx);
         }
     }
@@ -882,7 +882,7 @@ public:
     double get_rx_gain(const std::string &name, size_t chan){
         try {
             return rx_gain_group(chan)->get_value(name);
-        } catch (uhd::key_error &e) {
+        } catch (uhd::key_error &) {
             THROW_GAIN_NAME_ERROR(name,chan,rx);
         }
     }
@@ -905,7 +905,7 @@ public:
     gain_range_t get_rx_gain_range(const std::string &name, size_t chan){
         try {
             return rx_gain_group(chan)->get_range(name);
-        } catch (uhd::key_error &e) {
+        } catch (uhd::key_error &) {
             THROW_GAIN_NAME_ERROR(name,chan,rx);
         }
     }
@@ -1188,7 +1188,7 @@ public:
     void set_tx_gain(double gain, const std::string &name, size_t chan){
         try {
             return tx_gain_group(chan)->set_value(gain, name);
-        } catch (uhd::key_error &e) {
+        } catch (uhd::key_error &) {
             THROW_GAIN_NAME_ERROR(name,chan,tx);
         }
     }
@@ -1207,7 +1207,7 @@ public:
     double get_tx_gain(const std::string &name, size_t chan){
         try {
             return tx_gain_group(chan)->get_value(name);
-        } catch (uhd::key_error &e) {
+        } catch (uhd::key_error &) {
             THROW_GAIN_NAME_ERROR(name,chan,tx);
         }
     }
@@ -1230,7 +1230,7 @@ public:
     gain_range_t get_tx_gain_range(const std::string &name, size_t chan){
         try {
             return tx_gain_group(chan)->get_range(name);
-        } catch (uhd::key_error &e) {
+        } catch (uhd::key_error &) {
             THROW_GAIN_NAME_ERROR(name,chan,tx);
         }
     }
@@ -1352,7 +1352,7 @@ public:
     {
         if (_tree->exists(mb_root(mboard) / "gpio" / bank))
         {
-            return _tree->access<boost::uint64_t>(mb_root(mboard) / "gpio" / bank / attr).get();
+            return boost::uint32_t(_tree->access<boost::uint64_t>(mb_root(mboard) / "gpio" / bank / attr).get());
         }
         if (bank.size() > 2 and bank[1] == 'X')
         {
diff --git a/host/lib/usrp_clock/octoclock/octoclock_impl.cpp b/host/lib/usrp_clock/octoclock/octoclock_impl.cpp
index d55fab10e..b98d95725 100644
--- a/host/lib/usrp_clock/octoclock/octoclock_impl.cpp
+++ b/host/lib/usrp_clock/octoclock/octoclock_impl.cpp
@@ -417,7 +417,7 @@ std::string octoclock_impl::_get_images_help_message(const std::string &addr){
     try{
         image_location = uhd::find_image_path(image_name);
     }
-    catch(const std::exception &e){
+    catch(const std::exception &){
         return str(boost::format("Could not find %s in your images path.\n%s")
                    % image_name
                    % uhd::print_utility_error("uhd_images_downloader.py"));
diff --git a/host/tests/fp_compare_delta_test.cpp b/host/tests/fp_compare_delta_test.cpp
index a38c3d2b0..36ff14756 100644
--- a/host/tests/fp_compare_delta_test.cpp
+++ b/host/tests/fp_compare_delta_test.cpp
@@ -101,8 +101,8 @@ BOOST_AUTO_TEST_CASE(double_equality_operators) {
 
 BOOST_AUTO_TEST_CASE(float_inequality_operators) {
     // Test inequality operator, which is based on equality operator
-    fp_compare_delta<float> alpha = fp_compare_delta<float>(127.0);
-    fp_compare_delta<float> beta = fp_compare_delta<float>(alpha._value + 1.19e-3);
+    fp_compare_delta<float> alpha = fp_compare_delta<float>(127.0f);
+    fp_compare_delta<float> beta = fp_compare_delta<float>(alpha._value + 1.19e-3f);
 
     BOOST_CHECK(alpha != beta);
     BOOST_CHECK(alpha != float(alpha._value + 1.19e-3));
@@ -119,17 +119,17 @@ BOOST_AUTO_TEST_CASE(double_inequality_operators) {
 
 BOOST_AUTO_TEST_CASE(float_lessthan_operators) {
     // Test less-than operator
-    fp_compare_delta<float> alpha = fp_compare_delta<float>(274192.7);
-    fp_compare_delta<float> beta = fp_compare_delta<float>(alpha._value - 0.2);
+    fp_compare_delta<float> alpha = fp_compare_delta<float>(274192.7f);
+    fp_compare_delta<float> beta = fp_compare_delta<float>(alpha._value - 0.2f);
 
     BOOST_CHECK(beta < alpha);
     BOOST_CHECK(float(alpha._value - 0.2) < alpha);
 
     // Confirm false less-than case
-    fp_compare_delta<float> charlie = fp_compare_delta<float>(alpha._value - 1.2);
+    fp_compare_delta<float> charlie = fp_compare_delta<float>(alpha._value - 1.2f);
 
     BOOST_CHECK(not (alpha < charlie));
-    BOOST_CHECK(not (alpha < float(alpha._value - 1.2)));
+    BOOST_CHECK(not (alpha < float(alpha._value - 1.2f)));
 }
 
 BOOST_AUTO_TEST_CASE(double_lessthan_operators) {
@@ -149,14 +149,14 @@ BOOST_AUTO_TEST_CASE(double_lessthan_operators) {
 
 BOOST_AUTO_TEST_CASE(float_lessthanequals_operators) {
     // Test that <= correctly reports for equal values
-    fp_compare_delta<float> alpha = fp_compare_delta<float>(827.3);
+    fp_compare_delta<float> alpha = fp_compare_delta<float>(827.3f);
     fp_compare_delta<float> beta = fp_compare_delta<float>(alpha._value);
 
     BOOST_CHECK(alpha <= beta);
     BOOST_CHECK(alpha <= float(alpha._value));
 
     // Test that <= correctly reports for less-than values
-    fp_compare_delta<float> charlie = fp_compare_delta<float>(alpha._value - 1.2);
+    fp_compare_delta<float> charlie = fp_compare_delta<float>(alpha._value - 1.2f);
 
     BOOST_CHECK(charlie <= alpha);
     BOOST_CHECK(float(alpha._value - 1.2) <= alpha);
@@ -179,14 +179,14 @@ BOOST_AUTO_TEST_CASE(double_lessthanequals_operators) {
 
 BOOST_AUTO_TEST_CASE(float_greaterthan_operators) {
     // Test basic greater-than functionality
-    fp_compare_delta<float> alpha = fp_compare_delta<float>(98325.4);
-    fp_compare_delta<float> beta = fp_compare_delta<float>(alpha._value + 0.15);
+    fp_compare_delta<float> alpha = fp_compare_delta<float>(98325.4f);
+    fp_compare_delta<float> beta = fp_compare_delta<float>(alpha._value + 0.15f);
 
     BOOST_CHECK(beta > alpha);
     BOOST_CHECK(float(alpha._value + 0.15) > alpha);
 
     // Test false greater-than case
-    fp_compare_delta<float> charlie = fp_compare_delta<float>(alpha._value + 1.2);
+    fp_compare_delta<float> charlie = fp_compare_delta<float>(alpha._value + 1.2f);
 
     BOOST_CHECK(not (alpha > charlie));
     BOOST_CHECK(not (alpha > float(alpha._value + 1.2)));
@@ -209,14 +209,14 @@ BOOST_AUTO_TEST_CASE(double_greaterthan_operators) {
 
 BOOST_AUTO_TEST_CASE(float_greaterthanequals_operators) {
     // Test that >= correctly reports for equal values
-    fp_compare_delta<float> alpha = fp_compare_delta<float>(7834.89);
+    fp_compare_delta<float> alpha = fp_compare_delta<float>(7834.89f);
     fp_compare_delta<float> beta = fp_compare_delta<float>(alpha._value);
 
     BOOST_CHECK(alpha >= beta);
     BOOST_CHECK(alpha >= float(alpha._value));
 
     // Test that >= correctly reports for greater-than values
-    fp_compare_delta<float> charlie = fp_compare_delta<float>(alpha._value + 4.8);
+    fp_compare_delta<float> charlie = fp_compare_delta<float>(alpha._value + 4.8f);
 
     BOOST_CHECK(charlie >= alpha);
     BOOST_CHECK(float(alpha._value + 4.8) >= alpha);
diff --git a/host/tests/fp_compare_epsilon_test.cpp b/host/tests/fp_compare_epsilon_test.cpp
index 5790318c2..45687ad26 100644
--- a/host/tests/fp_compare_epsilon_test.cpp
+++ b/host/tests/fp_compare_epsilon_test.cpp
@@ -30,7 +30,7 @@ BOOST_AUTO_TEST_CASE(fp_compare_epsilon_constructors) {
     // Test constructor with specified epsilon
     fp_compare_epsilon<float> foxtrot = fp_compare_epsilon<float>(alpha._value,
             uhd::math::SINGLE_PRECISION_EPSILON);
-    fp_compare_epsilon<float> gamma = fp_compare_epsilon<float>(alpha._value, 2.0e-1);
+    fp_compare_epsilon<float> gamma = fp_compare_epsilon<float>(alpha._value, 2.0e-1f);
     BOOST_CHECK_EQUAL(alpha._epsilon, foxtrot._epsilon);
     BOOST_CHECK(not (alpha._epsilon == gamma._epsilon));
 
@@ -102,10 +102,10 @@ BOOST_AUTO_TEST_CASE(double_equality_operators) {
 BOOST_AUTO_TEST_CASE(float_inequality_operators) {
     // Test inequality operator, which is based on equality operator
     fp_compare_epsilon<float> alpha = fp_compare_epsilon<float>(127.0);
-    fp_compare_epsilon<float> beta = fp_compare_epsilon<float>(alpha._value + 1.19e-5);
+    fp_compare_epsilon<float> beta = fp_compare_epsilon<float>(alpha._value + 1.19e-5f);
 
     BOOST_CHECK(alpha != beta);
-    BOOST_CHECK(alpha != float(alpha._value + 1.19e-5));
+    BOOST_CHECK(alpha != float(alpha._value + 1.19e-5f));
 }
 
 BOOST_AUTO_TEST_CASE(double_inequality_operators) {
@@ -119,17 +119,17 @@ BOOST_AUTO_TEST_CASE(double_inequality_operators) {
 
 BOOST_AUTO_TEST_CASE(float_lessthan_operators) {
     // Test less-than operator
-    fp_compare_epsilon<float> alpha = fp_compare_epsilon<float>(274192.7);
-    fp_compare_epsilon<float> beta = fp_compare_epsilon<float>(alpha._value - 0.15);
+    fp_compare_epsilon<float> alpha = fp_compare_epsilon<float>(274192.7f);
+    fp_compare_epsilon<float> beta = fp_compare_epsilon<float>(alpha._value - 0.15f);
 
     BOOST_CHECK(beta < alpha);
     BOOST_CHECK(float(alpha._value - 0.15) < alpha);
 
     // Confirm false less-than case
-    fp_compare_epsilon<float> charlie = fp_compare_epsilon<float>(alpha._value - 1.2);
+    fp_compare_epsilon<float> charlie = fp_compare_epsilon<float>(alpha._value - 1.2f);
 
     BOOST_CHECK(not (alpha < charlie));
-    BOOST_CHECK(not (alpha < float(alpha._value - 1.2)));
+    BOOST_CHECK(not (alpha < float(alpha._value - 1.2f)));
 }
 
 BOOST_AUTO_TEST_CASE(double_lessthan_operators) {
@@ -149,14 +149,14 @@ BOOST_AUTO_TEST_CASE(double_lessthan_operators) {
 
 BOOST_AUTO_TEST_CASE(float_lessthanequals_operators) {
     // Test that <= correctly reports for equal values
-    fp_compare_epsilon<float> alpha = fp_compare_epsilon<float>(827.3);
+    fp_compare_epsilon<float> alpha = fp_compare_epsilon<float>(827.3f);
     fp_compare_epsilon<float> beta = fp_compare_epsilon<float>(alpha._value);
 
     BOOST_CHECK(alpha <= beta);
     BOOST_CHECK(alpha <= float(alpha._value));
 
     // Test that <= correctly reports for less-than values
-    fp_compare_epsilon<float> charlie = fp_compare_epsilon<float>(alpha._value - 1.2);
+    fp_compare_epsilon<float> charlie = fp_compare_epsilon<float>(alpha._value - 1.2f);
 
     BOOST_CHECK(charlie <= alpha);
     BOOST_CHECK(float(alpha._value - 1.2) <= alpha);
@@ -179,17 +179,17 @@ BOOST_AUTO_TEST_CASE(double_lessthanequals_operators) {
 
 BOOST_AUTO_TEST_CASE(float_greaterthan_operators) {
     // Test basic greater-than functionality
-    fp_compare_epsilon<float> alpha = fp_compare_epsilon<float>(98325.4);
-    fp_compare_epsilon<float> beta = fp_compare_epsilon<float>(alpha._value + 0.15);
+    fp_compare_epsilon<float> alpha = fp_compare_epsilon<float>(98325.4f);
+    fp_compare_epsilon<float> beta = fp_compare_epsilon<float>(alpha._value + 0.15f);
 
     BOOST_CHECK(beta > alpha);
     BOOST_CHECK(float(alpha._value + 0.15) > alpha);
 
     // Test false greater-than case
-    fp_compare_epsilon<float> charlie = fp_compare_epsilon<float>(alpha._value + 1.2);
+    fp_compare_epsilon<float> charlie = fp_compare_epsilon<float>(alpha._value + 1.2f);
 
     BOOST_CHECK(not (alpha > charlie));
-    BOOST_CHECK(not (alpha > float(alpha._value + 1.2)));
+    BOOST_CHECK(not (alpha > float(alpha._value + 1.2f)));
 }
 
 BOOST_AUTO_TEST_CASE(double_greaterthan_operators) {
@@ -209,17 +209,17 @@ BOOST_AUTO_TEST_CASE(double_greaterthan_operators) {
 
 BOOST_AUTO_TEST_CASE(float_greaterthanequals_operators) {
     // Test that >= correctly reports for equal values
-    fp_compare_epsilon<float> alpha = fp_compare_epsilon<float>(7834.89);
+    fp_compare_epsilon<float> alpha = fp_compare_epsilon<float>(7834.89f);
     fp_compare_epsilon<float> beta = fp_compare_epsilon<float>(alpha._value);
 
     BOOST_CHECK(alpha >= beta);
     BOOST_CHECK(alpha >= float(alpha._value));
 
     // Test that >= correctly reports for greater-than values
-    fp_compare_epsilon<float> charlie = fp_compare_epsilon<float>(alpha._value + 4.8);
+    fp_compare_epsilon<float> charlie = fp_compare_epsilon<float>(alpha._value + 4.8f);
 
     BOOST_CHECK(charlie >= alpha);
-    BOOST_CHECK(float(alpha._value + 4.8) >= alpha);
+    BOOST_CHECK(float(alpha._value + 4.8f) >= alpha);
 }
 
 BOOST_AUTO_TEST_CASE(double_greaterthanequals_operators) {
diff --git a/host/utils/b2xx_fx3_utils.cpp b/host/utils/b2xx_fx3_utils.cpp
index 081141048..bc14932f1 100644
--- a/host/utils/b2xx_fx3_utils.cpp
+++ b/host/utils/b2xx_fx3_utils.cpp
@@ -186,7 +186,7 @@ uhd::transport::usb_device_handle::sptr open_device(const boost::uint16_t vid, c
         if (!handle)
             std::cerr << "Cannot open device" << std::endl;
     }
-    catch(const std::exception &e) {
+    catch(const std::exception &) {
         std::cerr << "Failed to communicate with the device!" << std::endl;
         #ifdef UHD_PLATFORM_WIN32
         std::cerr << "The necessary drivers are not installed. Read the UHD Transport Application Notes for details:\nhttp://files.ettus.com/manual/page_transport.html" << std::endl;
@@ -208,7 +208,7 @@ b200_iface::sptr make_b200_iface(const uhd::transport::usb_device_handle::sptr &
         if (!b200)
             std::cerr << "Cannot create device interface" << std::endl;
     }
-    catch(const std::exception &e) {
+    catch(const std::exception &) {
         std::cerr << "Failed to communicate with the device!" << std::endl;
         #ifdef UHD_PLATFORM_WIN32
         std::cerr << "The necessary drivers are not installed. Read the UHD Transport Application Notes for details:\nhttp://files.ettus.com/manual/page_transport.html" << std::endl;
diff --git a/host/utils/query_gpsdo_sensors.cpp b/host/utils/query_gpsdo_sensors.cpp
index 05f918eb4..9a40d2b42 100644
--- a/host/utils/query_gpsdo_sensors.cpp
+++ b/host/utils/query_gpsdo_sensors.cpp
@@ -118,7 +118,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
       uhd::sensor_value_t rmc_string = usrp->get_mboard_sensor("gps_gprmc");
       std::cout << boost::format("Printing available NMEA strings:\n");
       std::cout << boost::format("%s\n%s\n%s\n") % gga_string.to_pp_string() % rmc_string.to_pp_string() % gps_time.to_pp_string();
-  } catch (std::exception &e) {
+  } catch (std::exception &) {
       std::cout << "NMEA strings not implemented for this device." << std::endl;
   }
   std::cout << boost::format("UHD Device time: %.0f seconds\n") % (last_pps_time.get_real_secs());
diff --git a/host/utils/usrp_cal_utils.hpp b/host/utils/usrp_cal_utils.hpp
index c027a4785..ccdb0a61d 100644
--- a/host/utils/usrp_cal_utils.hpp
+++ b/host/utils/usrp_cal_utils.hpp
@@ -249,7 +249,7 @@ static void capture_samples(
 
     // Right after the stream is started, there will be transient data.
     // That transient data is discarded and only "good" samples are returned.
-    size_t nsamps_to_discard = usrp->get_rx_rate() * 0.001; // 1ms to be discarded
+    size_t nsamps_to_discard = size_t(usrp->get_rx_rate() * 0.001); // 1ms to be discarded
     std::vector<samp_type> discard_buff(nsamps_to_discard);
 
     uhd::stream_cmd_t stream_cmd(uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE);