uhd: mpm: apply clang-format to all files

Applying formatting changes to all .cpp and .hpp files in the following
directories:
```
find host/examples/ -iname *.hpp -o -iname *.cpp | \
    xargs clang-format -i -style=file
find host/tests/ -iname *.hpp -o -iname *.cpp | \
    xargs clang-format -i -style=file
find host/lib/usrp/dboard/neon/ -iname *.hpp -o -iname *.cpp | \
    xargs clang-format -i -style=file
find host/lib/usrp/dboard/magnesium/ -iname *.hpp -o -iname *.cpp | \
    xargs clang-format -i -style=file
find host/lib/usrp/device3/ -iname *.hpp -o -iname *.cpp | \
    xargs clang-format -i -style=file
find host/lib/usrp/mpmd/ -iname *.hpp -o -iname *.cpp | \
    xargs clang-format -i -style=file
find host/lib/usrp/x300/ -iname *.hpp -o -iname *.cpp | \
    xargs clang-format -i -style=file
find host/utils/ -iname *.hpp -o -iname *.cpp | \
    xargs clang-format -i -style=file
find mpm/ -iname *.hpp -o -iname *.cpp | \
    xargs clang-format -i -style=file
```

Also formatted host/include/, except Cpp03 was used as a the language
standard instead of Cpp11.
```
sed -i 's/ Cpp11/ Cpp03/g' .clang-format
find host/include/ -iname *.hpp -o -iname *.cpp | \
    xargs clang-format -i -style=file
```

Formatting style was designated by the .clang-format file.

1 files changed, 117 insertions, 129 deletions

diff --git a/host/examples/gpio.cpp b/host/examples/gpio.cpp
index 537da80ca..0ed8d01ef 100644
--- a/host/examples/gpio.cpp
+++ b/host/examples/gpio.cpp
@@ -63,29 +63,29 @@
 // mask - a mask indicating which bits in the specified attribute register are
 //          to be changed (default is all bits).
 
-#include <uhd/utils/thread.hpp>
-#include <uhd/utils/safe_main.hpp>
-#include <uhd/usrp/multi_usrp.hpp>
 #include <uhd/convert.hpp>
-#include <boost/program_options.hpp>
+#include <uhd/usrp/multi_usrp.hpp>
+#include <uhd/utils/safe_main.hpp>
+#include <uhd/utils/thread.hpp>
+#include <stdint.h>
+#include <stdlib.h>
 #include <boost/format.hpp>
+#include <boost/program_options.hpp>
+#include <chrono>
 #include <csignal>
 #include <iostream>
 #include <thread>
-#include <chrono>
-#include <stdlib.h>
-#include <stdint.h>
 
-static const std::string        GPIO_DEFAULT_CPU_FORMAT = "fc32";
-static const std::string        GPIO_DEFAULT_OTW_FORMAT = "sc16";
-static const double             GPIO_DEFAULT_RX_RATE    = 500e3;
-static const double             GPIO_DEFAULT_TX_RATE    = 500e3;
-static const double             GPIO_DEFAULT_DWELL_TIME = 2.0;
-static const std::string        GPIO_DEFAULT_GPIO       = "FP0";
-static const size_t             GPIO_DEFAULT_NUM_BITS   = 11;
-static const std::string        GPIO_DEFAULT_CTRL       = "0x0";    // all as user controlled
-static const std::string        GPIO_DEFAULT_DDR        = "0x0";    // all as inputs
-static const std::string        GPIO_DEFAULT_OUT        = "0x0";
+static const std::string GPIO_DEFAULT_CPU_FORMAT = "fc32";
+static const std::string GPIO_DEFAULT_OTW_FORMAT = "sc16";
+static const double GPIO_DEFAULT_RX_RATE         = 500e3;
+static const double GPIO_DEFAULT_TX_RATE         = 500e3;
+static const double GPIO_DEFAULT_DWELL_TIME      = 2.0;
+static const std::string GPIO_DEFAULT_GPIO       = "FP0";
+static const size_t GPIO_DEFAULT_NUM_BITS        = 11;
+static const std::string GPIO_DEFAULT_CTRL       = "0x0"; // all as user controlled
+static const std::string GPIO_DEFAULT_DDR        = "0x0"; // all as inputs
+static const std::string GPIO_DEFAULT_OUT        = "0x0";
 
 static inline uint32_t GPIO_BIT(const size_t x)
 {
@@ -95,13 +95,15 @@ static inline uint32_t GPIO_BIT(const size_t x)
 namespace po = boost::program_options;
 
 static bool stop_signal_called = false;
-void sig_int_handler(int){stop_signal_called = true;}
+void sig_int_handler(int)
+{
+    stop_signal_called = true;
+}
 
 std::string to_bit_string(uint32_t val, const size_t num_bits)
 {
     std::string out;
-    for (int i = num_bits - 1; i >= 0; i--)
-    {
+    for (int i = num_bits - 1; i >= 0; i--) {
         std::string bit = ((val >> i) & 1) ? "1" : "0";
         out += "  ";
         out += bit;
@@ -109,39 +111,29 @@ std::string to_bit_string(uint32_t val, const size_t num_bits)
     return out;
 }
 
-void output_reg_values(
-    const std::string bank,
-    const uhd::usrp::multi_usrp::sptr &usrp,
-    const size_t num_bits
-) {
+void output_reg_values(const std::string bank,
+    const uhd::usrp::multi_usrp::sptr& usrp,
+    const size_t num_bits)
+{
     const std::vector<std::string> attrs = {
-        "CTRL",
-        "DDR",
-        "ATR_0X",
-        "ATR_RX",
-        "ATR_TX",
-        "ATR_XX",
-        "OUT",
-        "READBACK"
-    };
+        "CTRL", "DDR", "ATR_0X", "ATR_RX", "ATR_TX", "ATR_XX", "OUT", "READBACK"};
     std::cout << (boost::format("%10s ") % "Bit");
     for (int i = num_bits - 1; i >= 0; i--)
         std::cout << (boost::format(" %2d") % i);
     std::cout << std::endl;
-    for (const auto &attr : attrs) {
+    for (const auto& attr : attrs) {
         const uint32_t gpio_bits = uint32_t(usrp->get_gpio_attr(bank, attr));
-        std::cout
-            << (boost::format("%10s:%s")
-                % attr % to_bit_string(gpio_bits, num_bits))
-            << std::endl;
+        std::cout << (boost::format("%10s:%s") % attr
+                         % to_bit_string(gpio_bits, num_bits))
+                  << std::endl;
     }
 }
 
-int UHD_SAFE_MAIN(int argc, char *argv[])
+int UHD_SAFE_MAIN(int argc, char* argv[])
 {
     uhd::set_thread_priority_safe();
 
-    //variables to be set by po
+    // variables to be set by po
     std::string args;
     std::string cpu, otw;
     double rx_rate, tx_rate, dwell;
@@ -151,7 +143,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[])
     std::string ddr_str;
     std::string out_str;
 
-    //setup the program options
+    // setup the program options
     po::options_description desc("Allowed options");
     // clang-format off
     desc.add_options()
@@ -174,80 +166,80 @@ int UHD_SAFE_MAIN(int argc, char *argv[])
     po::store(po::parse_command_line(argc, argv, desc), vm);
     po::notify(vm);
 
-    //print the help message
-    if (vm.count("help")){
+    // print the help message
+    if (vm.count("help")) {
         std::cout << boost::format("gpio %s") % desc << std::endl;
         return ~0;
     }
 
-    //create a usrp device
+    // create a usrp device
     std::cout << std::endl;
-    std::cout << boost::format("Creating the usrp device with: %s...") % args << std::endl;
+    std::cout << boost::format("Creating the usrp device with: %s...") % args
+              << std::endl;
     uhd::usrp::multi_usrp::sptr usrp = uhd::usrp::multi_usrp::make(args);
     std::cout << boost::format("Using Device: %s") % usrp->get_pp_string() << std::endl;
 
-    //print out initial unconfigured state of FP GPIO
+    // print out initial unconfigured state of FP GPIO
     std::cout << "Initial GPIO values:" << std::endl;
     output_reg_values(gpio, usrp, num_bits);
 
-    //configure GPIO registers
-    uint32_t ddr = strtoul(ddr_str.c_str(), NULL, 0);
-    uint32_t out = strtoul(out_str.c_str(), NULL, 0);
-    uint32_t ctrl = 0;
-    uint32_t atr_idle = 0;
-    uint32_t atr_rx = 0;
-    uint32_t atr_tx = 0;
+    // configure GPIO registers
+    uint32_t ddr        = strtoul(ddr_str.c_str(), NULL, 0);
+    uint32_t out        = strtoul(out_str.c_str(), NULL, 0);
+    uint32_t ctrl       = 0;
+    uint32_t atr_idle   = 0;
+    uint32_t atr_rx     = 0;
+    uint32_t atr_tx     = 0;
     uint32_t atr_duplex = 0;
-    uint32_t mask = (1 << num_bits) - 1;
+    uint32_t mask       = (1 << num_bits) - 1;
 
-    if (!vm.count("bitbang"))
-    {
-        //set up GPIO outputs:
-        //GPIO[0] = ATR output 1 at idle
+    if (!vm.count("bitbang")) {
+        // set up GPIO outputs:
+        // GPIO[0] = ATR output 1 at idle
         ctrl |= GPIO_BIT(0);
         atr_idle |= GPIO_BIT(0);
         ddr |= GPIO_BIT(0);
 
-        //GPIO[1] = ATR output 1 during RX
+        // GPIO[1] = ATR output 1 during RX
         ctrl |= GPIO_BIT(1);
         ddr |= GPIO_BIT(1);
         atr_rx |= GPIO_BIT(1);
 
-        //GPIO[2] = ATR output 1 during TX
+        // GPIO[2] = ATR output 1 during TX
         ctrl |= GPIO_BIT(2);
         ddr |= GPIO_BIT(2);
         atr_tx |= GPIO_BIT(2);
 
-        //GPIO[3] = ATR output 1 during full duplex
+        // GPIO[3] = ATR output 1 during full duplex
         ctrl |= GPIO_BIT(3);
         ddr |= GPIO_BIT(3);
         atr_duplex |= GPIO_BIT(3);
 
-        //GPIO[4] = output
+        // GPIO[4] = output
         ddr |= GPIO_BIT(4);
     }
 
-    //set data direction register (DDR)
+    // set data direction register (DDR)
     usrp->set_gpio_attr(gpio, "DDR", ddr, mask);
 
-    //set control register
+    // set control register
     usrp->set_gpio_attr(gpio, "CTRL", ctrl, mask);
 
-    //set output values (OUT)
+    // set output values (OUT)
     usrp->set_gpio_attr(gpio, "OUT", out, mask);
 
-    //set ATR registers
+    // set ATR registers
     usrp->set_gpio_attr(gpio, "ATR_0X", atr_idle, mask);
     usrp->set_gpio_attr(gpio, "ATR_RX", atr_rx, mask);
     usrp->set_gpio_attr(gpio, "ATR_TX", atr_tx, mask);
     usrp->set_gpio_attr(gpio, "ATR_XX", atr_duplex, mask);
 
-    //print out initial state of FP GPIO
+    // print out initial state of FP GPIO
     std::cout << "\nConfigured GPIO values:" << std::endl;
     output_reg_values(gpio, usrp, num_bits);
     std::cout << std::endl;
 
-    //set up streams
+    // set up streams
     uhd::stream_args_t rx_args(cpu, otw);
     uhd::stream_args_t tx_args(cpu, otw);
     uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(rx_args);
@@ -257,20 +249,22 @@ int UHD_SAFE_MAIN(int argc, char *argv[])
     usrp->set_rx_rate(rx_rate);
     usrp->set_tx_rate(tx_rate);
 
-    //set up buffers for tx and rx
+    // set up buffers for tx and rx
     const size_t max_samps_per_packet = rx_stream->get_max_num_samps();
-    const size_t nsamps_per_buff = max_samps_per_packet;
-    std::vector<char> rx_buff(max_samps_per_packet*uhd::convert::get_bytes_per_item(cpu));
-    std::vector<char> tx_buff(max_samps_per_packet*uhd::convert::get_bytes_per_item(cpu));
-    std::vector<void *> rx_buffs, tx_buffs;
+    const size_t nsamps_per_buff      = max_samps_per_packet;
+    std::vector<char> rx_buff(
+        max_samps_per_packet * uhd::convert::get_bytes_per_item(cpu));
+    std::vector<char> tx_buff(
+        max_samps_per_packet * uhd::convert::get_bytes_per_item(cpu));
+    std::vector<void*> rx_buffs, tx_buffs;
     for (size_t ch = 0; ch < rx_stream->get_num_channels(); ch++)
-        rx_buffs.push_back(&rx_buff.front()); //same buffer for each channel
+        rx_buffs.push_back(&rx_buff.front()); // same buffer for each channel
     for (size_t ch = 0; ch < tx_stream->get_num_channels(); ch++)
-        tx_buffs.push_back(&tx_buff.front()); //same buffer for each channel
+        tx_buffs.push_back(&tx_buff.front()); // same buffer for each channel
 
     uhd::rx_metadata_t rx_md;
     uhd::tx_metadata_t tx_md;
-    tx_md.has_time_spec = false;
+    tx_md.has_time_spec  = false;
     tx_md.start_of_burst = true;
     uhd::time_spec_t stop_time;
     double timeout = 0.01;
@@ -278,61 +272,54 @@ int UHD_SAFE_MAIN(int argc, char *argv[])
     int loop = 0;
     uint32_t rb, expected;
 
-    //register signal handler
+    // register signal handler
     std::signal(SIGINT, &sig_int_handler);
 
-    if (!vm.count("bitbang"))
-    {
+    if (!vm.count("bitbang")) {
         // Test the mask parameter of the multi_usrp::set_gpio_attr API
         // We only need to test once with no dwell time
         std::cout << "\nTesting mask..." << std::flush;
-        //send a value of all 1's to the DDR with a mask for only upper most bit
+        // send a value of all 1's to the DDR with a mask for only upper most bit
         usrp->set_gpio_attr(gpio, "DDR", ~0, GPIO_BIT(num_bits - 1));
-        //upper most bit should now be 1, but all the other bits should be unchanged
-        rb = usrp->get_gpio_attr(gpio, "DDR") & mask;
+        // upper most bit should now be 1, but all the other bits should be unchanged
+        rb       = usrp->get_gpio_attr(gpio, "DDR") & mask;
         expected = ddr | GPIO_BIT(num_bits - 1);
         if (rb == expected)
             std::cout << "pass:" << std::endl;
         else
             std::cout << "fail:" << std::endl;
         output_reg_values(gpio, usrp, num_bits);
-        //restore DDR value
+        // restore DDR value
         usrp->set_gpio_attr(gpio, "DDR", ddr, mask);
     }
 
-    while (not stop_signal_called)
-    {
+    while (not stop_signal_called) {
         int failures = 0;
 
         if (vm.count("repeat"))
             std::cout << "Press Ctrl + C to quit..." << std::endl;
 
-        if (vm.count("bitbang"))
-        {
+        if (vm.count("bitbang")) {
             // dwell and continuously read back GPIO values
             stop_time = usrp->get_time_now() + dwell_time;
-            while (not stop_signal_called and usrp->get_time_now() < stop_time)
-            {
+            while (not stop_signal_called and usrp->get_time_now() < stop_time) {
                 rb = usrp->get_gpio_attr(gpio, "READBACK");
                 std::cout << "\rREADBACK: " << to_bit_string(rb, num_bits);
                 std::this_thread::sleep_for(std::chrono::milliseconds(10));
             }
             std::cout << std::endl;
-        }
-        else
-        {
+        } else {
             // test user controlled GPIO and ATR idle by setting bit 4 high for 1 second
-            std::cout << "\nTesting user controlled GPIO and ATR idle output..." << std::flush;
+            std::cout << "\nTesting user controlled GPIO and ATR idle output..."
+                      << std::flush;
             usrp->set_gpio_attr(gpio, "OUT", 1 << 4, 1 << 4);
             stop_time = usrp->get_time_now() + dwell_time;
-            while (not stop_signal_called and usrp->get_time_now() < stop_time)
-            {
+            while (not stop_signal_called and usrp->get_time_now() < stop_time) {
                 std::this_thread::sleep_for(std::chrono::milliseconds(100));
             }
-            rb = usrp->get_gpio_attr(gpio, "READBACK");
+            rb       = usrp->get_gpio_attr(gpio, "READBACK");
             expected = GPIO_BIT(4) | GPIO_BIT(0);
-            if ((rb & expected) != expected)
-            {
+            if ((rb & expected) != expected) {
                 ++failures;
                 std::cout << "fail:" << std::endl;
                 if ((rb & GPIO_BIT(0)) == 0)
@@ -352,16 +339,15 @@ int UHD_SAFE_MAIN(int argc, char *argv[])
             rx_cmd.stream_mode = uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS;
             rx_stream->issue_stream_cmd(rx_cmd);
             stop_time = usrp->get_time_now() + dwell_time;
-            while (not stop_signal_called and usrp->get_time_now() < stop_time)
-            {
+            while (not stop_signal_called and usrp->get_time_now() < stop_time) {
                 try {
                     rx_stream->recv(rx_buffs, nsamps_per_buff, rx_md, timeout);
-                } catch(...){}
+                } catch (...) {
+                }
             }
-            rb = usrp->get_gpio_attr(gpio, "READBACK");
+            rb       = usrp->get_gpio_attr(gpio, "READBACK");
             expected = GPIO_BIT(1);
-            if ((rb & expected) != expected)
-            {
+            if ((rb & expected) != expected) {
                 ++failures;
                 std::cout << "fail:" << std::endl;
                 std::cout << "Bit 1 should be set, but is not" << std::endl;
@@ -370,29 +356,29 @@ int UHD_SAFE_MAIN(int argc, char *argv[])
             }
             output_reg_values(gpio, usrp, num_bits);
             rx_stream->issue_stream_cmd(uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS);
-            //clear out any data left in the rx stream
+            // clear out any data left in the rx stream
             try {
                 rx_stream->recv(rx_buffs, nsamps_per_buff, rx_md, timeout);
-            } catch(...){}
+            } catch (...) {
+            }
             if (stop_signal_called)
                 break;
 
             // test ATR TX by transmitting for 1 second
             std::cout << "\nTesting ATR TX output..." << std::flush;
-            stop_time = usrp->get_time_now() + dwell_time;
+            stop_time            = usrp->get_time_now() + dwell_time;
             tx_md.start_of_burst = true;
-            tx_md.end_of_burst = false;
-            while (not stop_signal_called and usrp->get_time_now() < stop_time)
-            {
+            tx_md.end_of_burst   = false;
+            while (not stop_signal_called and usrp->get_time_now() < stop_time) {
                 try {
                     tx_stream->send(tx_buffs, nsamps_per_buff, tx_md, timeout);
                     tx_md.start_of_burst = false;
-                } catch(...){}
+                } catch (...) {
+                }
             }
-            rb = usrp->get_gpio_attr(gpio, "READBACK");
+            rb       = usrp->get_gpio_attr(gpio, "READBACK");
             expected = GPIO_BIT(2);
-            if ((rb & expected) != expected)
-            {
+            if ((rb & expected) != expected) {
                 ++failures;
                 std::cout << "fail:" << std::endl;
                 std::cout << "Bit 2 should be set, but is not" << std::endl;
@@ -403,7 +389,8 @@ int UHD_SAFE_MAIN(int argc, char *argv[])
             tx_md.end_of_burst = true;
             try {
                 tx_stream->send(tx_buffs, nsamps_per_buff, tx_md, timeout);
-            } catch(...){}
+            } catch (...) {
+            }
             if (stop_signal_called)
                 break;
 
@@ -412,20 +399,19 @@ int UHD_SAFE_MAIN(int argc, char *argv[])
             rx_cmd.stream_mode = uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS;
             rx_stream->issue_stream_cmd(rx_cmd);
             tx_md.start_of_burst = true;
-            tx_md.end_of_burst = false;
-            stop_time = usrp->get_time_now() + dwell_time;
-            while (not stop_signal_called and usrp->get_time_now() < stop_time)
-            {
+            tx_md.end_of_burst   = false;
+            stop_time            = usrp->get_time_now() + dwell_time;
+            while (not stop_signal_called and usrp->get_time_now() < stop_time) {
                 try {
                     tx_stream->send(rx_buffs, nsamps_per_buff, tx_md, timeout);
                     tx_md.start_of_burst = false;
                     rx_stream->recv(tx_buffs, nsamps_per_buff, rx_md, timeout);
-                } catch(...){}
+                } catch (...) {
+                }
             }
-            rb = usrp->get_gpio_attr(gpio, "READBACK");
+            rb       = usrp->get_gpio_attr(gpio, "READBACK");
             expected = GPIO_BIT(3);
-            if ((rb & expected) != expected)
-            {
+            if ((rb & expected) != expected) {
                 ++failures;
                 std::cout << "fail:" << std::endl;
                 std::cout << "Bit 3 should be set, but is not" << std::endl;
@@ -437,11 +423,13 @@ int UHD_SAFE_MAIN(int argc, char *argv[])
             tx_md.end_of_burst = true;
             try {
                 tx_stream->send(tx_buffs, nsamps_per_buff, tx_md, timeout);
-            } catch(...){}
-            //clear out any data left in the rx stream
+            } catch (...) {
+            }
+            // clear out any data left in the rx stream
             try {
                 rx_stream->recv(rx_buffs, nsamps_per_buff, rx_md, timeout);
-            } catch(...){}
+            } catch (...) {
+            }
 
             std::cout << std::endl;
             if (failures)
@@ -454,10 +442,10 @@ int UHD_SAFE_MAIN(int argc, char *argv[])
             break;
 
         if (not stop_signal_called)
-            std::cout << (boost::format("\nLoop %d completed")  % ++loop) << std::endl;
+            std::cout << (boost::format("\nLoop %d completed") % ++loop) << std::endl;
     }
 
-    //finished
+    // finished
     std::cout << std::endl << "Done!" << std::endl << std::endl;
 
     return EXIT_SUCCESS;