Merge branch 'maint'

11 files changed, 47 insertions, 46 deletions

diff --git a/host/tests/blockdef_test.cpp b/host/tests/blockdef_test.cpp
index 2cd06a43a..11ddc4b59 100644
--- a/host/tests/blockdef_test.cpp
+++ b/host/tests/blockdef_test.cpp
@@ -17,7 +17,7 @@
 
 #include <iostream>
 #include <map>
-#include <boost/cstdint.hpp>
+#include <stdint.h>
 #include <boost/assign/list_of.hpp>
 #include <boost/test/unit_test.hpp>
 #include <boost/format.hpp>
@@ -27,7 +27,7 @@
 using namespace uhd::rfnoc;
 
 BOOST_AUTO_TEST_CASE(test_lookup) {
-    std::map<boost::uint64_t, std::string> blocknames = boost::assign::list_of< std::pair<boost::uint64_t, std::string> >
+    std::map<uint64_t, std::string> blocknames = boost::assign::list_of< std::pair<uint64_t, std::string> >
         (0,                  "NullSrcSink")
         (0xFF70000000000000, "FFT")
         (0xF112000000000001, "FIR")
@@ -38,7 +38,7 @@ BOOST_AUTO_TEST_CASE(test_lookup) {
 
     std::cout << blocknames.size() << std::endl;
 
-    for (std::map<boost::uint64_t, std::string>::iterator it = blocknames.begin(); it != blocknames.end(); ++it) {
+    for (std::map<uint64_t, std::string>::iterator it = blocknames.begin(); it != blocknames.end(); ++it) {
         std::cout << "Testing " << it->second << " => " << str(boost::format("%016X") % it->first) << std::endl;
         blockdef::sptr block_definition = blockdef::make_from_noc_id(it->first);
         // If the previous function fails, it'll return a NULL pointer
diff --git a/host/tests/byteswap_test.cpp b/host/tests/byteswap_test.cpp
index 7d94bbfba..ca5e0cb19 100644
--- a/host/tests/byteswap_test.cpp
+++ b/host/tests/byteswap_test.cpp
@@ -19,21 +19,21 @@
 #include <uhd/utils/byteswap.hpp>
 
 BOOST_AUTO_TEST_CASE(test_byteswap16){
-    boost::uint16_t x = 0x0123;
-    boost::uint16_t y = 0x2301;
+    uint16_t x = 0x0123;
+    uint16_t y = 0x2301;
     BOOST_CHECK_EQUAL(uhd::byteswap(x), y);
 }
 
 BOOST_AUTO_TEST_CASE(test_byteswap32){
-    boost::uint32_t x = 0x01234567;
-    boost::uint32_t y = 0x67452301;
+    uint32_t x = 0x01234567;
+    uint32_t y = 0x67452301;
     BOOST_CHECK_EQUAL(uhd::byteswap(x), y);
 }
 
 BOOST_AUTO_TEST_CASE(test_byteswap64){
     //split up 64 bit constants to avoid long-long compiler warnings
-    boost::uint64_t x = 0x01234567 | (boost::uint64_t(0x89abcdef) << 32);
-    boost::uint64_t y = 0xefcdab89 | (boost::uint64_t(0x67452301) << 32);
+    uint64_t x = 0x01234567 | (uint64_t(0x89abcdef) << 32);
+    uint64_t y = 0xefcdab89 | (uint64_t(0x67452301) << 32);
     BOOST_CHECK_EQUAL(uhd::byteswap(x), y);
 }
 
diff --git a/host/tests/cast_test.cpp b/host/tests/cast_test.cpp
index 6b8a4c527..1bd09e1a5 100644
--- a/host/tests/cast_test.cpp
+++ b/host/tests/cast_test.cpp
@@ -17,14 +17,14 @@
 
 #include <iostream>
 #include <boost/test/unit_test.hpp>
-#include <boost/cstdint.hpp>
+#include <stdint.h>
 #include <uhd/utils/cast.hpp>
 
 BOOST_AUTO_TEST_CASE(test_mac_addr){
     std::string in = "0x0100";
-    boost::uint16_t correct_result = 256;
-    boost::uint16_t x = uhd::cast::hexstr_cast<boost::uint16_t>(in);
-    //boost::uint16_t x = uhd::cast::hexstr_cast(in);
+    uint16_t correct_result = 256;
+    uint16_t x = uhd::cast::hexstr_cast<uint16_t>(in);
+    //uint16_t x = uhd::cast::hexstr_cast(in);
     std::cout
         << "Testing hex -> uint16_t conversion. "
         << in << " == " << std::hex << x << "?" << std::endl;
diff --git a/host/tests/chdr_test.cpp b/host/tests/chdr_test.cpp
index f48073a09..cdad7f35e 100644
--- a/host/tests/chdr_test.cpp
+++ b/host/tests/chdr_test.cpp
@@ -28,7 +28,7 @@ static void pack_and_unpack(
     if_packet_info_t &if_packet_info_in
 ){
     // Temp buffer for packed packet
-    boost::uint32_t packet_buff[2048] = {0};
+    uint32_t packet_buff[2048] = {0};
 
     // Check input (must not be lazy)
     BOOST_REQUIRE(
@@ -46,7 +46,7 @@ static void pack_and_unpack(
         packet_buff, if_packet_info_in
     );
     std::cout << std::endl;
-    boost::uint32_t header_bits = (uhd::ntohx(packet_buff[0]) >> 28);
+    uint32_t header_bits = (uhd::ntohx(packet_buff[0]) >> 28);
     std::cout << boost::format("header bits = 0b%d%d%d%d") % ((header_bits & 8) > 0)
                                                            % ((header_bits & 4) > 0)
                                                            % ((header_bits & 2) > 0)
diff --git a/host/tests/convert_test.cpp b/host/tests/convert_test.cpp
index 84e7480a6..b5f63bcbb 100644
--- a/host/tests/convert_test.cpp
+++ b/host/tests/convert_test.cpp
@@ -18,7 +18,7 @@
 #include <uhd/convert.hpp>
 #include <boost/test/unit_test.hpp>
 #include <boost/foreach.hpp>
-#include <boost/cstdint.hpp>
+#include <stdint.h>
 #include <boost/assign/list_of.hpp>
 #include <complex>
 #include <vector>
@@ -28,7 +28,7 @@
 using namespace uhd;
 
 //typedefs for complex types
-typedef std::complex<boost::int16_t> sc16_t;
+typedef std::complex<int16_t> sc16_t;
 typedef std::complex<float> fc32_t;
 typedef std::complex<double> fc64_t;
 
@@ -51,7 +51,7 @@ template <typename Range> static void loopback(
     const int prio_out = -1
 ){
     //make this buffer large enough for all test types
-    std::vector<boost::uint64_t> interm(nsamps);
+    std::vector<uint64_t> interm(nsamps);
 
     std::vector<const void *> input0(1, &input[0]), input1(1, &interm[0]);
     std::vector<void *> output0(1, &interm[0]), output1(1, &output[0]);
@@ -288,7 +288,7 @@ BOOST_AUTO_TEST_CASE(test_convert_types_fc32_to_sc16){
         (std::rand()/float(RAND_MAX/2)) - 1,
         (std::rand()/float(RAND_MAX/2)) - 1
     );
-    std::vector<boost::uint32_t> interm(nsamps);
+    std::vector<uint32_t> interm(nsamps);
     std::vector<sc16_t> output(nsamps);
 
     std::vector<const void *> input0(1, &input[0]), input1(1, &interm[0]);
@@ -333,7 +333,7 @@ BOOST_AUTO_TEST_CASE(test_convert_types_sc16_to_fc32){
         std::rand()-(RAND_MAX/2),
         std::rand()-(RAND_MAX/2)
     );
-    std::vector<boost::uint32_t> interm(nsamps);
+    std::vector<uint32_t> interm(nsamps);
     std::vector<fc32_t> output(nsamps);
 
     std::vector<const void *> input0(1, &input[0]), input1(1, &interm[0]);
@@ -423,10 +423,10 @@ static void test_convert_types_u8(
     size_t nsamps, convert::id_type &id
 ){
     //fill the input samples
-    std::vector<boost::uint8_t> input(nsamps), output(nsamps);
-    BOOST_FOREACH(boost::uint8_t &in, input) in = boost::uint8_t(std::rand() & 0xFF);
-    //boost::uint32_t d = 48;
-    //BOOST_FOREACH(boost::uint8_t &in, input) in = d++;
+    std::vector<uint8_t> input(nsamps), output(nsamps);
+    BOOST_FOREACH(uint8_t &in, input) in = uint8_t(std::rand() & 0xFF);
+    //uint32_t d = 48;
+    //BOOST_FOREACH(uint8_t &in, input) in = d++;
 
     //run the loopback and test
     convert::id_type in_id = id;
@@ -463,8 +463,8 @@ static void test_convert_types_s8(
     size_t nsamps, convert::id_type &id
 ){
     //fill the input samples
-    std::vector<boost::int8_t> input(nsamps), output(nsamps);
-    BOOST_FOREACH(boost::int8_t &in, input) in = boost::int8_t(std::rand() & 0xFF);
+    std::vector<int8_t> input(nsamps), output(nsamps);
+    BOOST_FOREACH(int8_t &in, input) in = int8_t(std::rand() & 0xFF);
 
     //run the loopback and test
     convert::id_type in_id = id;
@@ -501,8 +501,8 @@ static void test_convert_types_s16(
     size_t nsamps, convert::id_type &id
 ){
     //fill the input samples
-    std::vector<boost::int16_t> input(nsamps), output(nsamps);
-    BOOST_FOREACH(boost::int16_t &in, input) in = boost::int16_t(std::rand() & 0xFFFF);
+    std::vector<int16_t> input(nsamps), output(nsamps);
+    BOOST_FOREACH(int16_t &in, input) in = int16_t(std::rand() & 0xFFFF);
 
     //run the loopback and test
     convert::id_type in_id = id;
diff --git a/host/tests/device3_test.cpp b/host/tests/device3_test.cpp
index 593facb9a..657436717 100644
--- a/host/tests/device3_test.cpp
+++ b/host/tests/device3_test.cpp
@@ -27,7 +27,7 @@
 using namespace uhd;
 using namespace uhd::rfnoc;
 
-static const boost::uint64_t TEST_NOC_ID = 0xAAAABBBBCCCCDDDD;
+static const uint64_t TEST_NOC_ID = 0xAAAABBBBCCCCDDDD;
 static const sid_t TEST_SID0 = 0x00000200; // 0.0.2.0
 static const sid_t TEST_SID1 = 0x00000210; // 0.0.2.F
 
@@ -38,11 +38,11 @@ class pseudo_wb_iface_impl : public uhd::wb_iface
     pseudo_wb_iface_impl() {};
     ~pseudo_wb_iface_impl() {};
 
-    void poke64(const wb_addr_type addr, const boost::uint64_t data) {
+    void poke64(const wb_addr_type addr, const uint64_t data) {
         std::cout << str(boost::format("[PSEUDO] poke64 to addr: %016X, data == %016X") % addr % data) << std::endl;
     };
 
-    boost::uint64_t peek64(const wb_addr_type addr) {
+    uint64_t peek64(const wb_addr_type addr) {
         std::cout << str(boost::format("[PSEUDO] peek64 to addr: %016X") % addr) << std::endl;
         switch (addr) {
             case SR_READBACK_REG_ID:
@@ -57,11 +57,11 @@ class pseudo_wb_iface_impl : public uhd::wb_iface
         return 0;
     }
 
-    void poke32(const wb_addr_type addr, const boost::uint32_t data) {
+    void poke32(const wb_addr_type addr, const uint32_t data) {
         std::cout << str(boost::format("poke32 to addr: %08X, data == %08X") % addr % data) << std::endl;
     }
 
-    boost::uint32_t peek32(const wb_addr_type addr) {
+    uint32_t peek32(const wb_addr_type addr) {
         std::cout << str(boost::format("peek32 to addr: %08X") % addr) << std::endl;
         return 0;
     }
diff --git a/host/tests/math_test.cpp b/host/tests/math_test.cpp
index 6c890c484..8a92e074f 100644
--- a/host/tests/math_test.cpp
+++ b/host/tests/math_test.cpp
@@ -16,7 +16,7 @@
 //
 
 #include <boost/test/unit_test.hpp>
-#include <boost/cstdint.hpp>
+#include <stdint.h>
 #include <uhd/utils/math.hpp>
 
 // NOTE: This is not the only math test case, see e.g. special tests
diff --git a/host/tests/sph_recv_test.cpp b/host/tests/sph_recv_test.cpp
index a22e7a7c2..e10926834 100644
--- a/host/tests/sph_recv_test.cpp
+++ b/host/tests/sph_recv_test.cpp
@@ -72,18 +72,18 @@ public:
 
     void push_back_packet(
         uhd::transport::vrt::if_packet_info_t &ifpi,
-        const boost::uint32_t optional_msg_word = 0
+        const uint32_t optional_msg_word = 0
     ){
-        const size_t max_pkt_len = (ifpi.num_payload_words32 + uhd::transport::vrt::max_if_hdr_words32 + 1/*tlr*/)*sizeof(boost::uint32_t);
+        const size_t max_pkt_len = (ifpi.num_payload_words32 + uhd::transport::vrt::max_if_hdr_words32 + 1/*tlr*/)*sizeof(uint32_t);
         _mems.push_back(boost::shared_array<char>(new char[max_pkt_len]));
         if (_end == "big"){
-            uhd::transport::vrt::if_hdr_pack_be(reinterpret_cast<boost::uint32_t *>(_mems.back().get()), ifpi);
+            uhd::transport::vrt::if_hdr_pack_be(reinterpret_cast<uint32_t *>(_mems.back().get()), ifpi);
         }
         if (_end == "little"){
-            uhd::transport::vrt::if_hdr_pack_le(reinterpret_cast<boost::uint32_t *>(_mems.back().get()), ifpi);
+            uhd::transport::vrt::if_hdr_pack_le(reinterpret_cast<uint32_t *>(_mems.back().get()), ifpi);
         }
-        (reinterpret_cast<boost::uint32_t *>(_mems.back().get()) + ifpi.num_header_words32)[0] = optional_msg_word | uhd::byteswap(optional_msg_word);
-        _lens.push_back(ifpi.num_packet_words32*sizeof(boost::uint32_t));
+        (reinterpret_cast<uint32_t *>(_mems.back().get()) + ifpi.num_header_words32)[0] = optional_msg_word | uhd::byteswap(optional_msg_word);
+        _lens.push_back(ifpi.num_packet_words32*sizeof(uint32_t));
     }
 
     uhd::transport::managed_recv_buffer::sptr get_recv_buff(double){
diff --git a/host/tests/sph_send_test.cpp b/host/tests/sph_send_test.cpp
index 9cd195c7e..39c7429db 100644
--- a/host/tests/sph_send_test.cpp
+++ b/host/tests/sph_send_test.cpp
@@ -56,12 +56,12 @@ public:
     void pop_front_packet(
         uhd::transport::vrt::if_packet_info_t &ifpi
     ){
-        ifpi.num_packet_words32 = _lens.front()/sizeof(boost::uint32_t);
+        ifpi.num_packet_words32 = _lens.front()/sizeof(uint32_t);
         if (_end == "big"){
-            uhd::transport::vrt::if_hdr_unpack_be(reinterpret_cast<boost::uint32_t *>(_mems.front().get()), ifpi);
+            uhd::transport::vrt::if_hdr_unpack_be(reinterpret_cast<uint32_t *>(_mems.front().get()), ifpi);
         }
         if (_end == "little"){
-            uhd::transport::vrt::if_hdr_unpack_le(reinterpret_cast<boost::uint32_t *>(_mems.front().get()), ifpi);
+            uhd::transport::vrt::if_hdr_unpack_le(reinterpret_cast<uint32_t *>(_mems.front().get()), ifpi);
         }
         _mems.pop_front();
         _lens.pop_front();
diff --git a/host/tests/time_spec_test.cpp b/host/tests/time_spec_test.cpp
index b98bea7d9..76dfb1930 100644
--- a/host/tests/time_spec_test.cpp
+++ b/host/tests/time_spec_test.cpp
@@ -21,6 +21,7 @@
 #include <boost/thread.hpp> //sleep
 #include <iostream>
 #include <iomanip>
+#include <stdint.h>
 
 BOOST_AUTO_TEST_CASE(test_time_spec_compare){
     std::cout << "Testing time specification compare..." << std::endl;
@@ -102,7 +103,7 @@ BOOST_AUTO_TEST_CASE(test_time_spec_neg_values){
 BOOST_AUTO_TEST_CASE(test_time_large_ticks_to_time_spec)
 {
     std::cout << "sizeof(time_t) " << sizeof(time_t) << std::endl;
-    const boost::uint64_t ticks0 = boost::uint64_t(100e6*1360217663.739296);
+    const uint64_t ticks0 = uint64_t(100e6*1360217663.739296);
     const uhd::time_spec_t t0 = uhd::time_spec_t::from_ticks(ticks0, 100e6);
     std::cout << "t0.get_real_secs() " << t0.get_real_secs() << std::endl;
     std::cout << "t0.get_full_secs() " << t0.get_full_secs() << std::endl;
diff --git a/host/tests/vrt_test.cpp b/host/tests/vrt_test.cpp
index 62284b239..f9dc5aafa 100644
--- a/host/tests/vrt_test.cpp
+++ b/host/tests/vrt_test.cpp
@@ -29,9 +29,9 @@ static void pack_and_unpack(
 ){
     if (if_packet_info_in.num_payload_bytes == 0)
     {
-        if_packet_info_in.num_payload_bytes = if_packet_info_in.num_payload_words32 * sizeof(boost::uint32_t);
+        if_packet_info_in.num_payload_bytes = if_packet_info_in.num_payload_words32 * sizeof(uint32_t);
     }
-    boost::uint32_t packet_buff[2048];
+    uint32_t packet_buff[2048];
 
     //pack metadata into a vrt header
     vrt::if_hdr_pack_be(